上传了一些SubDiffusion生成三维线稿数据的代码

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+jupyter/生成模型旋转动画.ipynb filter=lfs diff=lfs merge=lfs -text

jupyter/ZoeDepth深度检测.ipynb

@@ -0,0 +1,177 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "f564c670-1fa4-4b68-91e9-344e0c29e268",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using cache found in C:\\Users\\胡逸飞/.cache\\torch\\hub\\isl-org_ZoeDepth_main\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "img_size [384, 512]\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using cache found in C:\\Users\\胡逸飞/.cache\\torch\\hub\\intel-isl_MiDaS_master\n",
+      "D:\\SubDiffusion\\venv\\lib\\site-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:3484.)\n",
+      "  return _VF.meshgrid(tensors, **kwargs)  # type: ignore[attr-defined]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Params passed to Resize transform:\n",
+      "\twidth:  512\n",
+      "\theight:  384\n",
+      "\tresize_target:  True\n",
+      "\tkeep_aspect_ratio:  True\n",
+      "\tensure_multiple_of:  32\n",
+      "\tresize_method:  minimal\n",
+      "Using pretrained resource url::https://github.com/isl-org/ZoeDepth/releases/download/v1.0/ZoeD_M12_N.pt\n",
+      "Loaded successfully\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "import os\n",
+    "import torchvision.transforms as transforms\n",
+    "import matplotlib.pyplot as plt\n",
+    "from PIL import Image\n",
+    "import numpy as np\n",
+    "import cv2\n",
+    "import matplotlib.cm as cm\n",
+    "from einops import rearrange\n",
+    "repo = \"isl-org/ZoeDepth\"\n",
+    "# Zoe_N\n",
+    "model_zoe_n = torch.hub.load(repo, \"ZoeD_N\", pretrained=True)\n",
+    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+    "model = model_zoe_n.to(DEVICE)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "id": "309a4ce8-72d5-4d76-8eee-a85c66e5ae79",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 44,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "image = Image.open('7.jpg')\n",
+    "# 调整图像到正方形\n",
+    "max_size = 960\n",
+    "if image.size[0] > image.size[1]:\n",
+    "    wpercent = max_size / float(image.size[0])\n",
+    "    hsize = int((float(image.size[1]) * float(wpercent)))\n",
+    "    image = image.resize((max_size, hsize), Image.Resampling.BILINEAR)\n",
+    "else:\n",
+    "    hpercent = max_size / float(image.size[1])\n",
+    "    wsize = int((float(image.size[0]) * float(hpercent)))\n",
+    "    image = image.resize((wsize, max_size), Image.Resampling.BILINEAR)\n",
+    "\n",
+    "    # 创建一个n1*n1的纯黑色图像\n",
+    "    background = Image.new('RGB', (960, 960), (0, 0, 0))\n",
+    "\n",
+    "# 计算输入图像在背景图像中的位置\n",
+    "bg_w, bg_h = background.size\n",
+    "img_w, img_h = image.size\n",
+    "offset = ((bg_w - img_w) // 2, (bg_h - img_h) // 2)\n",
+    "\n",
+    "# 将输入图像放在背景图像中\n",
+    "background.paste(image, offset)\n",
+    "input_image=np.array(background)\n",
+    "\n",
+    "# 将图像转换为张量\n",
+    "#input_image = transforms.ToTensor()(background).unsqueeze(0).to(device)\n",
+    "image_depth = input_image\n",
+    "with torch.no_grad():\n",
+    "    image_depth = torch.from_numpy(image_depth).float().to(device)\n",
+    "    image_depth = image_depth / 255.0\n",
+    "    image_depth = rearrange(image_depth, 'h w c -> 1 c h w')\n",
+    "    depth = model.infer(image_depth)\n",
+    "\n",
+    "    depth = depth[0, 0].cpu().numpy()\n",
+    "\n",
+    "    vmin = np.percentile(depth, 2)\n",
+    "    vmax = np.percentile(depth, 85)\n",
+    "\n",
+    "    depth -= vmin\n",
+    "    depth /= vmax - vmin\n",
+    "    depth = 1.0 - depth\n",
+    "    depth_image = (depth * 255.0).clip(0, 255).astype(np.uint8)\n",
+    "cv2.imwrite('depth_image.png', depth_image)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "id": "f0786ef5-0413-41cd-b54f-e012fc178aca",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "id": "1e802ea9-0905-43d1-8ad2-5195c6a3054d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 42,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "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.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

jupyter/亮度分类训练集.ipynb

@@ -0,0 +1,89 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "f1614722-84e7-4494-87ec-3a36867fd694",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import cv2\n",
+    "import numpy as np\n",
+    "import shutil\n",
+    "\n",
+    "def classify_images_by_brightness(directory):\n",
+    "    brightness_dict = {}\n",
+    "    \n",
+    "    # 遍历文件夹中的每个图像\n",
+    "    for filename in os.listdir(directory):\n",
+    "        if filename.endswith(\".jpg\") or filename.endswith(\".png\"):\n",
+    "            # 读取图像\n",
+    "            img = cv2.imread(os.path.join(directory, filename))\n",
+    "            if img is not None:\n",
+    "                # 计算图像的平均亮度\n",
+    "                avg_brightness = np.average(img)\n",
+    "                brightness_dict[filename] = avg_brightness\n",
+    "    \n",
+    "    # 将图像按亮度排序\n",
+    "    sorted_images = sorted(brightness_dict.items(), key=lambda item: item[1])\n",
+    "    \n",
+    "    # 创建子文件夹\n",
+    "    if not os.path.exists(directory + '/low'):\n",
+    "        os.makedirs(directory + '/low')\n",
+    "    if not os.path.exists(directory + '/medium'):\n",
+    "        os.makedirs(directory + '/medium')\n",
+    "    if not os.path.exists(directory + '/high'):\n",
+    "        os.makedirs(directory + '/high')\n",
+    "    \n",
+    "    # 将图像归类到对应的子文件夹\n",
+    "    for i in range(len(sorted_images)):\n",
+    "        if i < len(sorted_images) / 3:\n",
+    "            shutil.move(directory + '/' + sorted_images[i][0], directory + '/low/' + sorted_images[i][0])\n",
+    "        elif i < 2 * len(sorted_images) / 3:\n",
+    "            shutil.move(directory + '/' + sorted_images[i][0], directory + '/medium/' + sorted_images[i][0])\n",
+    "        else:\n",
+    "            shutil.move(directory + '/' + sorted_images[i][0], directory + '/high/' + sorted_images[i][0])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "fbd8f248-6c31-4842-a18f-c73e77f5cc9b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "classify_images_by_brightness('928\\\\humansubd')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8b7fa525-ce8c-4b2b-a4a6-b5751cb53873",
+   "metadata": {},
+   "outputs": [],
+   "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.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

jupyter/创建不同的角点识别图.ipynb

@@ -0,0 +1,136 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "c0770659-9fb1-4f0c-ba36-b50ff8bb0dfa",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1079, 1080, 3)\n",
+      "41\n",
+      "41\n",
+      "507\n",
+      "50\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\胡逸飞\\AppData\\Local\\Temp\\ipykernel_336\\2072798907.py:16: DeprecationWarning: `np.int0` is a deprecated alias for `np.intp`.  (Deprecated NumPy 1.24)\n",
+      "  for [[x, y]] in np.int0(harris):  # 注意这里的双重方括号\n",
+      "C:\\Users\\胡逸飞\\AppData\\Local\\Temp\\ipykernel_336\\2072798907.py:25: DeprecationWarning: `np.int0` is a deprecated alias for `np.intp`.  (Deprecated NumPy 1.24)\n",
+      "  for [[x, y]] in np.int0(shi):  # 注意这里的双重方括号\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfwAAAGzCAYAAADKXKWqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAACNXUlEQVR4nOzdeXhU5fnw8e+ZfbLMZN8gkLAIYUdRiKK2mooWt4pWLFVqKVgFrfJWKS2CO4r9VSuiqG1RW9DWtlpXlKItVVkUNwRE9rAlMQmZSUhmf94/howMBMhMJslMcn+u6yg52zyznPs+y7NoSimFEEIIIbo0XWcXQAghhBDtTxK+EEII0Q1IwhdCCCG6AUn4QgghRDcgCV8IIYToBiThCyGEEN2AJHwhhBCiG5CEL4QQQnQDkvCFEEKIbkASvmg3//nPf9A0jf/85z+dXRQhug1N05gxY8ZJ13v22WfRNI1du3a1+TWbj/W///3vbd6XaD+S8LuY5oP4448/bnH5d77zHYYMGdLBpRJCxMKGDRu48sor6d27NxaLhR49evC9732PhQsXxvy1NE1r1SQn9InD0NkFEF3XOeecQ1NTEyaTqbOLIkTC+/DDD/nud79Lr169mDp1Knl5eezZs4c1a9bw+9//nptvvjmi/V177bVMnDgRs9nc4vI///nPYX8///zzrFix4pj5JSUlbN68ObI3IzqFJHwRFaUULpcLq9V6zDKXy4XJZEKn02GxWDqhdEJ0Pffffz92u52PPvqItLS0sGVVVVUR70+v16PX64+7/Mc//nHY32vWrGHFihXHzAck4ScIuaXfzS1ZsoTzzjuPnJwczGYzgwYN4sknnzxmvaKiIi6++GLefvttRo0ahdVq5amnngo9u3vxxReZM2cOPXr0ICkpCafT2eIz/K1btzJhwgTy8vKwWCz07NmTiRMn4nA4OvBdC5F4tm/fzuDBg49J9gA5OTnHzHvllVcYMmQIZrOZwYMHs3z58rDlsXyG3ywQCHD//ffTs2dPLBYL559/Ptu2bTtmvZdeeonTTjsNq9VKVlYWP/7xj9m3b1/YOj/5yU9ISUmhvLyciy++mJSUFHr06MGiRYuA4OON8847j+TkZHr37s2yZcvCtq+treWXv/wlQ4cOJSUlBZvNxkUXXcTnn39+THkWLlzI4MGDSUpKIj09nVGjRh2zv65ArvC7KIfDQXV19THzvV5v2N9PPvkkgwcP5tJLL8VgMPDaa69x0003EQgEmD59eti6W7Zs4ZprruGGG25g6tSpDBgwILTs3nvvxWQy8ctf/hK3293ibXyPx8O4ceNwu93cfPPN5OXlsW/fPl5//XXq6uqw2+0xevdCdD29e/dm9erVfPnllyeth/P+++/zz3/+k5tuuonU1FQee+wxJkyYQHl5OZmZme1WxgcffBCdTscvf/lLHA4HCxYsYNKkSaxduza0zrPPPsv111/P6aefzvz586msrOT3v/89H3zwAZ9++mnYCY3f7+eiiy7inHPOYcGCBSxdupQZM2aQnJzMb37zGyZNmsQVV1zB4sWLue666ygtLaW4uBiAHTt28Morr3DVVVdRXFxMZWUlTz31FOeeey6bNm2ioKAAgGeeeYZbbrmFK6+8kl/84he4XC6++OIL1q5dy49+9KN2+6w6hRJdypIlSxRwwmnw4MGh9RsbG4/Zx7hx41SfPn3C5vXu3VsBavny5WHz33vvPQWoPn36HLOv5mXvvfeeUkqpTz/9VAHqpZdeitG7FaL7eOedd5Rer1d6vV6VlpaqO+64Q7399tvK4/GErQcok8mktm3bFpr3+eefK0AtXLgwNK85VuzcubNVrz99+nR1vJTRfKyXlJQot9sdmv/73/9eAWrDhg1KKaU8Ho/KyclRQ4YMUU1NTaH1Xn/9dQWouXPnhuZNnjxZAeqBBx4IzTt48KCyWq1K0zT14osvhuZ/9dVXClDz5s0LzXO5XMrv94eVc+fOncpsNqt77rknNO+yyy4Li4ldmdzS76IWLVrEihUrjpmGDRsWtt6Rz+Cb7wqce+657Nix45jb7MXFxYwbN67F15s8eXKLz/OP1HwF//bbb9PY2BjN2xKi2/re977H6tWrufTSS/n8889ZsGAB48aNo0ePHrz66qth65aVldG3b9/Q38OGDcNms7Fjx452LeP1118fdnfv7LPPBgi97scff0xVVRU33XRTWP2e8ePHM3DgQN54441j9vmzn/0s9O+0tDQGDBhAcnIyP/zhD0PzBwwYQFpaWtj7M5vN6HTBFOf3+6mpqSElJYUBAwbwySefhO1z7969fPTRR219+3FPEn4XdcYZZ1BWVnbMlJ6eHrbeBx98QFlZGcnJyaSlpZGdnc2vf/1rgBYT/vGcaNmR68ycOZM//OEPZGVlMW7cOBYtWiTP74VopdNPP51//vOfHDx4kHXr1jF79mzq6+u58sor2bRpU2i9Xr16HbNteno6Bw8ePO6+HQ4HFRUVoam2tjbi8h39us3xpvl1d+/eDRD2OLDZwIEDQ8ubWSwWsrOzw+bZ7XZ69uyJpmnHzD/y/QUCAR555BH69++P2WwmKyuL7Oxsvvjii7CYM2vWLFJSUjjjjDPo378/06dP54MPPoj0rScESfjd2Pbt2zn//POprq7md7/7HW+88QYrVqzgtttuA4IHzJFOdAV/sqv7Zv/3f//HF198wa9//Wuampq45ZZbGDx4MHv37o3+jQjRzZhMJk4//XQeeOABnnzySbxeLy+99FJo+fFq3yuljrvPX/ziF+Tn54emK664IuJyRfO60eyvNa/zwAMPMHPmTM455xz+8pe/8Pbbb7NixQoGDx4cFttKSkrYsmULL774ImPHjuUf//gHY8eOZd68eVGVOZ5Jpb1u7LXXXsPtdvPqq6+GnZm/99577fq6Q4cOZejQocyZM4cPP/yQs846i8WLF3Pfffe16+sK0RWNGjUKgAMHDrRpP3fccUdYk7uj7wbGQu/evYFgBeDzzjsvbNmWLVtCy2Ph73//O9/97nf54x//GDa/rq6OrKyssHnJyclcffXVXH311Xg8Hq644gruv/9+Zs+e3aWaFssVfjfWfJZ85Fmxw+FgyZIl7fJ6TqcTn88XNm/o0KHodDrcbne7vKYQXcV7773X4pXym2++CbR8mzwSgwYNCnv8d9ppp7Vpfy0ZNWoUOTk5LF68OOyYf+utt9i8eTPjx4+P2Wvp9fpjPq+XXnrpmOZ/NTU1YX+bTCYGDRqEUuqYVk2JTq7wu7ELLrgAk8nEJZdcwg033EBDQwPPPPMMOTk5bb5aaMm7777LjBkzuOqqqzjllFPw+Xz8+c9/Rq/XM2HChJi/nhBdyc0330xjYyM/+MEPGDhwIB6Phw8//JC//vWvFBUVcf3113d2EU/KaDTy0EMPcf3113PuuedyzTXXhJrlFRUVhR4nxsLFF1/MPffcw/XXX8+ZZ57Jhg0bWLp0KX369Alb74ILLiAvL4+zzjqL3NxcNm/ezOOPP8748eNJTU2NWXnigST8bmzAgAH8/e9/Z86cOfzyl78kLy+PG2+8kezsbH7605/G/PWGDx/OuHHjeO2119i3bx9JSUkMHz6ct956izFjxsT89YToSn7729/y0ksv8eabb/L000/j8Xjo1asXN910E3PmzGmxQ5549JOf/ISkpCQefPBBZs2aRXJyMj/4wQ946KGHYvoefv3rX3Po0CGWLVvGX//6V0499VTeeOMNfvWrX4Wtd8MNN7B06VJ+97vf0dDQQM+ePbnllluYM2dOzMoSLzQVbW0KIYQQQiQMeYYvhBBCdAOS8IUQQohuQBK+EEII0Q3EdcJftGgRRUVFWCwWRo8ezbp16zq7SEKIBCCxQ4hjxW3C/+tf/8rMmTOZN28en3zySaiGdzTjPgshug+JHUK0LG5r6Y8ePZrTTz+dxx9/HAh281pYWMjNN998TLMKIYRoJrFDiJbFZTt8j8fD+vXrmT17dmieTqejrKyM1atXt7iN2+0O67kpEAhQW1tLZmbmMYMsCNHZlFLU19dTUFAQGtFLtF2ksUPihkg0bYkdcZnwq6ur8fv95Obmhs3Pzc3lq6++anGb+fPnc/fdd3dE8YSImT179tCzZ8/OLkaXEWnskLghElU0sSMuE340Zs+ezcyZM0N/OxwOevXqxZ5dO7HZbJ1YMiGO5XQ6KSwq7nJddyYaiRsi0bQldsRlws/KykKv11NZWRk2v7Kykry8vBa3MZvNmM3mY+bbbDY5cEXcktvGsRVp7JC4IRJVNLEjLh8emkwmTjvtNFauXBmaFwgEWLlyJaWlpZ1YMiFEPJPYIcTxxeUVPsDMmTOZPHkyo0aN4owzzuDRRx/l0KFDCTEilBCi80jsEKJlcZvwr776ar755hvmzp1LRUUFI0aMYPny5cdUxhFCiCNJ7BCiZXHbDr+tnE4ndrsdR22NPIsTccfpdGLPyMThcMjvM45I3BDxri2xIy6f4QshhBAitiThCyGEEN2AJHwhhBCiG5CEL4QQQnQDkvCFEEKIbiBum+V1pF274D//hbKyWszmQNT7cbt1/PvfGYw6rZ7cPPfJN4gD1dUmVq+2UVZ2EKvV39nFaZX9+yx89nky3ys7iNHUuu/L79NY+V46/fq6qKoyYrHA6ac3YjQY0BsM6HV69HpdsPcqDQ7/J0T6wxNHi1XcqDhgYf0nKXyvrBZTG/bTkbxeHf9emc7QwY30LGzq7OKcnIKPPrYDcPooR6sP6LqDRlb9z85ZZ9WzZk0qp49qoGdPP4YEjRuS8IHVaxR33QMlg7zkF0Sf9Pbv13PXPTBrlp/x4z0xLGH7Wfexnnl3Q9/+XoqLfZ1dnFZ5b5WRhQth8FAvOTmt+76cTh3zH4TLLgvwyScKmy1Acd86AgEffr8fvy+4H6UUmgaapkOv06E3GDDq9RiMBowGA0ajEYPBgMFoxKDXo9Pp0Ol0R3VzGTz4VQA8HjCbQXrQ7XpiFTf++76Rhx8OUDLYS35+Ypx019TouOfeANOm+Zk4Mf5jXSAAz/xR4ff7GTTEQ2sHmftsg8adcxX33efj7nsUd9zh4cIL6/H72y9uoBSgtUvMkHb4QEXFQfbsdzFwYEarfwgtCQRg/fq9DB1agMWSGE9LPB7Fp5/uZdSoQvT6zi5N6zQ2+tm06QCnntqz1d+XUvD55wcoLs6iuroBk8lAz56pwLc/fw0NdfhvpRRKBQOE3+/H5/MFJ68Xr89HwO/H7w8QCPgJBALogkc7Ol3wgDcY9GzYkMHDv81k6Z/9FBWFl0fa4cenzogbbjd88skuTj+9FwZDYsSNQECxdu0uRo4sxmLp7NKcnFJQW+tnz569DB/eu9XJ1OuFTz/dy+DBOezcWU9OjoHs7PDfRazjxpo1uTQ0pPCzKarFmNyW2CFX+IDRGCA729+mgxZAp4O0tCaMxsQ5hzIaIT29KWGSPYDJpEhPd0f0fWkapKW5sVgCpKZ6MRqbr7qPvgWnHbGNhv7wB9N8XqxpGkeeIx/9t1KKQCCA3+8nxdZI794HSE7OPuZ1ROKLVdwwmyEry4umJU7c0DTIzPQmRLKHYHntdkVdnS+iK2ejEXJyfBgMipwcP0bj0Vflh/cfo7jh8/lZs05RXu7m+p8Y0etjGzck4QvRgqMP6iP/PtkynU6HUors7Bp+9StIz8gEEuiMSggRlVjEjcmTy0Fp6PSnEOu4kRj3j4RIIEopysvLyc3NxWQy4fN6O7tIQog41xw3evbMISXF0C5xQxK+EDFWX1+PyWQiJSUFg9GIy50YLTaEEJ2nI+KGJHwhYsjv97N3714KCgrQNA2L2Yzb7aaL1o0VQsRAR8UNSfhCxEBz7dwDBw5QUFAQqrRjMptxu+QKXwhxrI6OG5LwhYgJDYejAa/Xi90e7OBDKYXRaMTtkYQvhDiW369RVXUIj6dj4oYkfCHaQKHw+Xz8/e8BbrwxifS0wrAGeAaDAa/XhzTLE0I0a44bf/iDj4kTU7HbOyZuSLM8IaKglMLj8VBVVYXP48ZiKiI5WWE0GUPrNDe7CQQCBDv4kaQvRHd2dNwYUlJIxTkukpNTQuu0Z9yQhC/ESSilDh9ywR61GhoaqP7mG4wGAwX5eaSmpDB4kMbgwZtJSioO60c32CGHRiAQCD2fE0J0fa2NGz16bsZsTu6QuCEJX4jjaD5gNTT8AT8Oh4ODtbWkpqTQv28fTCZT+EHa4om4Qm/Q4/P5JOEL0Q1EGjeOs5d2iRuS8IVopoL/UXx7W83n91NVVYWrqZGsjEwGDRyA3mBAO6q5zHEbz2gaBoMBt8eD2Wxux8ILITpFAsWNmFfamz9/Pqeffjqpqank5ORw+eWXs2XLlrB1XC4X06dPJzMzk5SUFCZMmEBlZWXYOuXl5YwfP56kpCRycnK4/fbb8fkSYzQ3kfiaGhvZt3cve/eUk5WexuCSEvLy8zAYDIdHwdRaNQSeUgqzxYzL7Wr3MicyiRuiK4j3uBHzhP/f//6X6dOns2bNGlasWIHX6+WCCy7g0KFDoXVuu+02XnvtNV566SX++9//sn//fq644orQcr/fz/jx4/F4PHz44Yc899xzPPvss8ydOzfWxRUi1BZWoXDW17Nzxw4O1tbSsyCfQQMHkpaeHhzKMsr9m0zSFv9kJG6IRJOIcSPmt/SXL18e9vezzz5LTk4O69ev55xzzsHhcPDHP/6RZcuWcd555wGwZMkSSkpKWLNmDWPGjOGdd95h06ZN/Pvf/yY3N5cRI0Zw7733MmvWLO66667gMxAhYqB5lKra2loanE5sqakM6N8Po9HY4qhYkdI0DZPJRIPTKRX1T0DihkgkiRo32r0dvsPhACAjIwOA9evX4/V6KSsrC60zcOBAevXqxerVqwFYvXo1Q4cOJTc3N7TOuHHjcDqdbNy4scXXcbvdOJ3OsKm1FBqBgEZbezFUCpTSkUhRvbnMidbzq1KRfV/B96kRCEBVlR6vV4fH46HiwAF27dxJktlMycABFBYWYjKZYnLQBl9XYTAY8Ljdx39eJ46RCHEjViRudJzuHjfatdJeIBDg1ltv5ayzzmLIkCEAVFRUYDKZSEtLC1s3NzeXioqK0DpHHrTNy5uXtWT+/PncfffdUZXz009TWbgomfvvd2KzeaLaB4DDYWLu3L5MmeJi5MiGqPfTkTZvTuaxx/px3331ZGYmxm3ndetSWbq0D/ff7yAlpXUjSrndBu67rzeDBgX44x/zueXm/Vw8vo6cnBz6FhcBzeE29pfhOp2OAApQKHXsMJkiXKLEjQMVFpa/o+Oyyw5iMvmj2gdI3OgoEjfaOeFPnz6dL7/8kvfff789XwaA2bNnM3PmzNDfTqeTwsLCVm/f/Fm29UNtrpORSEE9Vu+9I0VXZkVqqosbpjm44HupnNK/IIp9RCcQCD7vS6TPuLMkStzYsCGJRYuSGDu2ioICiRuJoLvHjXZL+DNmzOD1119n1apV9OzZMzQ/Ly8Pj8dDXV1d2Nl6ZWUleXl5oXXWrVsXtr/m2rjN6xzNbDZH3Xxh5Mh6Hn2kieycrNZUoDyujAy4557t9OlTjF5viX5HHeissxQ5Ods45ZR+bXrvHemCC3yccsoOevfu0+oyKwW//vVO7HYbDQ315OXE5lnbyTS/hsFgwOfzyXPkk0ikuPHd79Txt7+5GDgwA10bHo5K3OgYEjfa4Rm+UooZM2bw8ssv8+6771JcXBy2/LTTTsNoNLJy5crQvC1btlBeXk5paSkApaWlbNiwgaqqqtA6K1aswGazMWjQoFgXGQ2FplNt/uEGt2/uDjExBK8qAglz0DbTtMi+r87+boxGIx5P624jdkeJGDeMxgDZ2f42JXvo/N9mNCRudIxYx42YX+FPnz6dZcuW8a9//YvU1NTQszO73Y7VasVutzNlyhRmzpxJRkYGNpuNm2++mdLSUsaMGQPABRdcwKBBg7j22mtZsGABFRUVzJkzh+nTp0vnJSIhmUwm3G43KSnJnV2UuCRxQ4hjxTpuxDzhP/nkkwB85zvfCZu/ZMkSfvKTnwDwyCOPoNPpmDBhAm63m3HjxvHEE0+E1tXr9bz++uvceOONlJaWkpyczOTJk7nnnntiXVwhOoTJHOxEQ1rmtUzihhDHinXciHnCV61o82CxWFi0aBGLFi067jq9e/fmzTffjGXRhOg0JpMJx6HEqIHdGSRuCHGsWMeNdm+HL4QIVr4JPotLnOe0QojOFeu4IQlfiA6g1+vx+f2S74UQrRbruCEJX4hYULBtWxJ797Z8SAUCGg0Nbe/NUQjRdfh98Pd/5LJihb7F2BDruCHD4woRAy4XPPBgEYMH13PzzTs5+pR8zZo0Hn+8H2++plFU1ClFFELEGZ8f1q2zUVPrpHfvvccsj3XckIQvRAxYLPCb2TsZUFJAYeEpxyzXNI2vvnJis6UhN9aEEABmU7DTpb79emMyDThmeazjhkQeIWJBg759m+jZM9Di4v79FdOmVWKztbxcCNENaWAxBzAaW14c67ghCV+IDpBoPZIJITpfrOOGJHwhhBCiG5CEL4QQQnQDkvCFEEKIbkASvhBCCNENSMIHFBqBQNs7N1AKlNIBWqv6Bo8HzWVOkOKGKBXZ9xVcN/jdHDVTiE4lcaPjdPe4Ie3wgU8+SWXhomTuv9+B3R792MMOh5E77+zLz37mYuTIxBgoZdOmZB57rB/33eckK8vT2cVplbVrU1m6tA/33+8gNbV135fbree++4oYPbqJxkYdV1xmITNDqs6L6O0/YGH5Ozouu+wgZrM/6v1I3OgYEjck4QOg00CvD3ZyoLWhHYSmaTHZT0fSYvTeO5JOFyyzTkery6xpGgaDhseTzJ/+lM6A/orBg9u5oKJL+/LLJJ54IolzzqkiP1/iRryTuAGaSpR7SBFyOp3Y7XYctTXYbLYTrltdU0v9oSays7Pa1O5RKdi2bTt9+hSj1yfG05JAQLF163ZOOaVfwrQV9/l87NpVTt++fVpdZqVg9+5yCgsL2bG9nvw8I7k5aTErkwI2btxMUZ/i4waTnTt3MLB/fwwGQ/D3mZGJw+E46e9TdJxI4kZFxUH2HnAxYEAGujYc7hI3OkZXiBtAm2JHYvy62pmGQtNUm3+4we0DJNKQaJoGmhZImIO2WaTfV/B9KnQ6yM4JYDRIj3eibYzGAFlZ/jYle5C40ZG6e9yQhC+EEEJ0A5LwhRBCiG5AEr4QQgjRDUjCF0IIIbqBdk/4Dz74IJqmceutt4bmuVwupk+fTmZmJikpKUyYMIHKysqw7crLyxk/fjxJSUnk5ORw++234/P52ru4QrSLrtkWpv1I3BAi9nGjXRP+Rx99xFNPPcWwYcPC5t9222289tprvPTSS/z3v/9l//79XHHFFaHlfr+f8ePH4/F4+PDDD3nuued49tlnmTt3bnsWV4joKIXfBy/9PZd33jGglDpm+vprjSefzMPhlJtqJyNxQ3QLnRA32q3jnYaGBiZNmsQzzzzDfffdF5rvcDj44x//yLJlyzjvvPMAWLJkCSUlJaxZs4YxY8bwzjvvsGnTJv7973+Tm5vLiBEjuPfee5k1axZ33XUXJpOpvYotRKupw//x+Xzs3VfDunUZHKxzUlS095h1P/wwlfff701DvY7MjA4vasKQuCG6us6MG+2W8KdPn8748eMpKysLO3DXr1+P1+ulrKwsNG/gwIH06tWL1atXM2bMGFavXs3QoUPJzc0NrTNu3DhuvPFGNm7cyMiRI495PbfbjdvtDv3tdDrb6Z2JbkupYMNcBQqF2+1m7779uD0e7GlpPP/nAAZDMibTgCM2Ufh8PizmA1zzQy8ZGeZOfAPxT+KG6HLiKG60S8J/8cUX+eSTT/joo4+OWVZRUYHJZCItLS1sfm5uLhUVFaF1jjxom5c3L2vJ/Pnzufvuu2NQeiFapjQNlMLpdHKgohJfIEBuTi7WJCtoGi315+F2u9lbvodT+vfFYjWjKQUtrikkboiuKJ7iRswT/p49e/jFL37BihUrsFgssd79cc2ePZuZM2eG/nY6nRQWFnbY64uuqbnOTMDvp6amlspvqrBYrOTm52M0Gk/YJ3dTYxM7dmxncEkJFqs1eLgmWtdkHUTihuhK4jVuxDzhr1+/nqqqKk499dTQPL/fz6pVq3j88cd5++238Xg81NXVhZ2tV1ZWkpeXB0BeXh7r1q0L229zbdzmdY5mNpsxm+V2qYiN5iEmvF4vFZWVOJxOUm02ehcVo9PpTnjAKhRul5t9e/cwdPAgLBaLXNOfhMQN0RXEe9yIeZXh888/nw0bNvDZZ5+FplGjRjFp0qTQv41GIytXrgxts2XLFsrLyyktLQWgtLSUDRs2UFVVFVpnxYoV2Gw2Bg0aFOsiCwEEz8oVwYO2sbGR7Tt2snnL15gsFor79CUrOwed/vgHbfPB7na5qa2upqRkIBarVa7qW0HihkhUiRQ3Yn6Fn5qaypAhQ8LmJScnk5mZGZo/ZcoUZs6cSUZGBjabjZtvvpnS0lLGjBkDwAUXXMCgQYO49tprWbBgARUVFcyZM4fp06fL2biInSMeiylABQI4HA72V1Sg1xvIzMoir6DgqOdsxzloD/+/oaGBmupv6N+3LwajQa7sW0nihkgYCRw32q2W/ok88sgj6HQ6JkyYgNvtZty4cTzxxBOh5Xq9ntdff50bb7yR0tJSkpOTmTx5Mvfcc09nFFd0YQrw+3xUV1fzTXUN1qQkevQsDA1F2fojL1gpZ//evQwfNhSDwUDL1XFEtCRuiHiRqHGjQxL+f/7zn7C/LRYLixYtYtGiRcfdpnfv3rz55pvtXLIghUYgoIVaT0S9HwVK6UikWtjNZW7re+9okX5fwfcZ3CYQANBwe9zsP3CA+kOHSE9Lp6hPH3RRjHWqlKKhvp6qigpGDB+GXq8/4bM60TrxHjc8Xh2VlQYyM2nTELkSNzpOW+JGc+W5RI4bnXKFH28++SSVxx5P4YEH6rDbvVHvp67OyJw5ffnZz1ycempDDEvYfjZuTOaxx/pz//0OsrI8nV2cVlmzJpWlS/vwwAN1pKa2rttUl0vP3Xf3orRUz3vvZXLFFfs4/fRKMjOzyM7Ni/pAU0pxqOEQDfVOhg4ZfNKKOaLreO+9NGb/Bl58sZKCAn/U+5G40THaEjfOO0+jqSmFwYMO0KNn4sYNSfgEz84NBoVOp7XpQ9fpNAwG0Ovbtp+OpNdrGI1tf+8dSa8Pfs6RlDn43Sg0zY+mQVZWJr17R//zb65o43Q4aGpspE9xMdpx2tSKrmn4sEZu/YWH7GyJG4mgLXGjpkbxzDNJ3H13IWeeFX0H950dNzTVXIIuxul0YrfbcdTWYLPZTrhudU0t9YeayM7OavMt/W3bttOnTzF6fWL0mR4IKLZt20b//v0T5tacz+dj165y+vbtE9GtuV27dlNQkMfBgw7MZiPp6elRvb4KdpnFN1VVHGpoYFDJwFAAaW0gcTqd2DMycTgcJ/19io4TSdyoqamhvrGJrKysNiU9iRsdoy1xIy8vj507G8jKMpCTY4/q9WMRN6BtsUOu8AENhaapNv9wg9sH+LbuZfwLlrnt772jRfp9aVpwG2jb81YAFFRVVdF06FDUB63oOtr6vUvc6DjRxg2dDrKy/BiNbams0flxQxK+EBFQSnGwtha9BiUDBwRvxyVa1BNCdKh4iRuJcf9IiDiglKK6uhqdBr0KCyXZCyFOKp7ihiR8IU6ieWzqPeXlaCpAQX4+GonUiEoI0dHiMW5IwhfiOI6sz7pr506sZlPwDL15plzdCyGOEs9xQ57hC3EcmqahlKLiwAHS0+wU5OcfubDzCiaEiFvxHDck4QvRguaz9MqKCtLtNjIyMuR5vRDihOI9bsgtfSFaoJRi544d2FJT4u6gFULEp3iPG5LwhTiK3+9n29atZGVmkJWZGXcHrRAi/iRC3JBb+kIQPDPXNI2AP8Ce8nJ6FhSQlZXZ6c/chBDxK9HihiR8IQ7z+/1UHDhAzx4F2FJT4/IMXQgRXxIpbsgtfdHtKaXw+XyUl+8mPzcn7g9aIUTnS8S4IQlfdGtKKbxeL19v2UJhQQEpKSlxf9AKITpXosYNuaUvuq3mM/RtW7cycMAppKakSu95QogTSuS4IQlfdFs+n48D+/czZFAJFqsVTam4rWwjhIgPiRw35JY+4PHqqKw0EAi0bT+BANTWWvF4EuPLB/B4gmX2+zu7JK3ndmvU1loi+r6UgoMHzRw6pKOyUk9Dg5f9+/bRp6goeNBCwhy0Ij7EKm4oBUrpSKTRGZrLrBJnRF+U0qisNOB2R7INNDQY+OYbHRUViR835AofeO+9dGb/RrFs2QHy831R72f/fgM/+Ulf7rijlu9/vyGGJWw///lPEnfe2Y8///kARUXezi5Oq7z8ciqLFhXzwrL9ZOe07kyl3qlj2rRejB7tYuXKfKbfVM4vbinCZDYlUJgV8SRWccPhMPGb3/RlypQmRo50xrCE7WfTphQWLuzPffcdJDMzggzaifbsMfCTn/Rj7tyDfO97h1q93cKFuaxfn4zTmcwtNyd23GiXhL9v3z5mzZrFW2+9RWNjI/369WPJkiWMGjUKCD4DmTdvHs888wx1dXWcddZZPPnkk/Tv3z+0j9raWm6++WZee+01dDodEyZM4Pe//z0pKSkxL+/oM3z8eNI23K469u+L/lLX49FzzTW15Oe52L8vMQ6C7Cwrk35USSDQwP590QetjtSzh4mrr06isbG+1d+X36/j8suqGT7Czojhdi6/rDdmcyJdU3V93TVu1Neb8bh1fPPNN+zfVxe7Araj6uo0fL5cKg7sw+1q6uzitEpTo2LSpFry87zs39fY6u1GDN/L6NF98PvN/CDB40bME/7Bgwc566yz+O53v8tbb71FdnY2W7duJT09PbTOggULeOyxx3juuecoLi7mzjvvZNy4cWzatAmLxQLApEmTOHDgACtWrMDr9XL99dczbdo0li1bFusiU1ys48ILq7HZbG2qaamA75VVkpSURHJy/DfRAEhNVYwdu4Oc7KLOLkqrBQJ15OY2kp6e3qrPuLl/67Fj9zOwJB1bqiIzQ6El7GHb9XTnuJGaCrNmfUlSkpWUlMSIGyNH+ElPW0OvXr3RNGNnF6dVAoE6vn9RzeG4YTvp+s1xY9Cg/QwscWNLNSZ83Ih5wn/ooYcoLCxkyZIloXnFxcWhfyulePTRR5kzZw6XXXYZAM8//zy5ubm88sorTJw4kc2bN7N8+XI++uij0Nn9woUL+f73v89vf/tbCgoKYlpmTdOwpdrw+XwYjdH/eDUgKSmJpqYmkpOTY1dAAXx7ADY1NZGWlhbRtn6/H5PZRCDgJ8lqJXHP0bumbh03NEhOttLU1ERKSuLEDU1TCfH4WuLGt2Jeae/VV19l1KhRXHXVVeTk5DBy5EieeeaZ0PKdO3dSUVFBWVlZaJ7dbmf06NGsXr0agNWrV5OWlhY6aAHKysrQ6XSsXbu2xdd1u904nc6wKRLZ2dk0NjaGjWUcDYvFgsvlatM+xIl5PB5MJlOrr4Q0TcPlcmGxWEmyJmE2WxL8sO16JG5I3GhvEjfaIeHv2LEj9Fzt7bff5sYbb+SWW27hueeeA6CiogKA3NzcsO1yc3NDyyoqKsjJyQlbbjAYyMjICK1ztPnz52O320NTYWFhROXOzMjA5237M2y9Xo/XkxiV3xKSCp6x63S6iIKs2+0mOTkJnU6HLhEuS7oZiRsSN9qVxA2gHRJ+IBDg1FNP5YEHHmDkyJFMmzaNqVOnsnjx4li/VJjZs2fjcDhC0549e1q9raZpmEym0HPAttA0Db1eTyAQaPNZvwinaRpenxedTh/xtm63G7PJdPi2HCRUe6JuQOKGxI32InHjWzFP+Pn5+QwaNChsXklJCeXl5QDk5eUBUFlZGbZOZWVlaFleXh5VVVVhy30+H7W1taF1jmY2m7HZbGFTpDIyMvB4PBFvdzSL1YLL7U6IyjeJxuVykZQUPPha+/kqFewjwWK1YrVagtvJdxNXJG5I3GhPEjeCYp7wzzrrLLZs2RI27+uvv6Z3795AsCJOXl4eK1euDC13Op2sXbuW0tJSAEpLS6mrq2P9+vWhdd59910CgQCjR4+OdZFDsrOyaWxsoq3ncFarlabG1jf7EK2jlKKpqYmkpKSIgqJSAUBhNBox6KXriXgkcUPiRnuRuPGtmCf82267jTVr1vDAAw+wbds2li1bxtNPP8306dOB4NnVrbfeyn333cerr77Khg0buO666ygoKODyyy8Hgmf2F154IVOnTmXdunV88MEHzJgxg4kTJ8a8pu2RbLZUVCDQ5ooZUgGn/bjdbsxmc0TbeL1eTOYjbsuJuCNxQ+JGe5K4ERTz05bTTz+dl19+mdmzZ3PPPfdQXFzMo48+yqRJk0Lr3HHHHRw6dIhp06ZRV1fH2LFjWb58edizsKVLlzJjxgzOP//8UAcajz32WKyLG6IRrDiTlJSE3+9Hr4/8eU8zg8GA1+tDKSW352LM7/ej00V2nup2u0lOSiI5KXGaPHU3EjckbrQniRtBmuqiNUScTid2ux1HbU2rn8spYNeuXVRUVrS5Hf2uXbspLOzZpgDQEZRS7N69m6Kios4uykn5fD72799Pr169ItqusrKSXr16cUq//nETSJ1OJ/aMTBwOR1TPjUX7kLjROhI3Ok9bYocMnnMETSmys7LwuNteAcdkMuLxeKTGbQw1NTVFXCO6edzq9LT0k68sRBQkbsQ3iRvfkoR/BEWwp7xI22q2pLnHPREbR1a8ifS7CSiFNanrPIcT8UXiRvySuBFOEv5RNE0j1ZaKz+eL+uBVSmG1WqUCTgxpmhaqeBPJ7bVAIIDFbMFiMid8kxoRvyRuxCeJG+Ek4R+huZ1lTnY2TU1NUT+30TQNo9EYk7a5Ikgphd/vx2CIrJ6px+PBbrOj1+vR5DapaAcSN+KXxI1wkvCPogEZ6Rl4vd423Z7TNE16zYqhaGrZNt/OS0tP6xKdZoj4JXEjPkncCCcJvwVmsxmjITj6VVsOPLPZjNcr/WPHgtvtxmg0Rnz15PF4SE1J6VIHrYhPEjfij8SNcJLwW6JpZGVl4na727QbqzU45KWcrbedy+UiOTk54s/S7/djS02lzd2gCXEyEjfijsSNcJLwW6ARHPayrZVnrNYkmppccdWGM1FF07QGgp2imM1mtK525Iq4I3Ej/kjcCCcJ/zjsNjt+vz/q7YMjaRlxu11d7CfT8ZRS+Hy+iG/N+Xw+UlJSg8/wJHiKDiBxI35I3DiWJPzj0Ov1JFmTCAQCUe8jVFlEbs21SbTfgdvtJiszgzZ3ci5EK0nciB8SN44lCf8Emm/PteVZml6vlwo4beTxeCJuRwvgcrtJS0vrcs/hRHyTuBEfJG4cSxL+8WgaWZmZuF3RV8DRNC3UkYZUwIlOcxMZawQjVjV/1j6vl9SU1K54oi7ilcSNuCBxo2WS8E8gJSUFnS76r7255yzpKrNtXC5XRAcuBD97g8EQ8ZCYQrSVxI34IHHjWJLwj0MjeKZtt7etEo7FYmlzM53uzuv1YjQaI9omEFAkJyV3uY4zRHyTuBE/JG4cSxL+iWgaWVnZUZ9pa5qGTqfD5/PFuGDdh1IKpYj4OZzX68GWKsPOik4gcaPTSdxomST8k8hIz2jT8zgAg8HQprP97szj8WAw6KPqKSvUNaYQHUziRueSuNEySfgnYbGYMZlMbao8Y7FYZASsKLlcrqiGtvR5fcGuMYXoBBI3OpfEjZZJwj+B4ChJGpkZGVGPYKVpmoxx3QbNNW2jOeOOpoctIdpK4kbnk7jRMkn4J6JpoAXb1bblwDObzXLgRqj5zNzj8UR1pWQyGdHr9e1RNCFOTOJGp5G4cWKS8E9GKexpdgL+6IesbH4WJ21qW0/TtOBY1oFAxMNb+v1+kpO73khXIoFI3OgUEjdOLOYJ3+/3c+edd1JcXIzVaqVv377ce++9YT9apRRz584lPz8fq9VKWVkZW7duDdtPbW0tkyZNwmazkZaWxpQpU2hoaIh1cU9KAwx6A1ar9XDNz8gPPk3T0Ov1UgEnQl6vF6PBEPF2Ho8nONKVSBgSN1rYh8SNqEjcOL6YJ/yHHnqIJ598kscff5zNmzfz0EMPsWDBAhYuXBhaZ8GCBTz22GMsXryYtWvXkpyczLhx48IqqEyaNImNGzeyYsUKXn/9dVatWsW0adNiXdxW0YDMzMyoK9AopTCZTLg9Hjlbj0A0HWfA4bGsU1OlL/IEInHjWBI3oiNx4/hinvA//PBDLrvsMsaPH09RURFXXnklF1xwAevWrQOCP+JHH32UOXPmcNlllzFs2DCef/559u/fzyuvvALA5s2bWb58OX/4wx8YPXo0Y8eOZeHChbz44ovs378/1kU+scMdMORkZ9PY2BjV7R5N07AmJeFqauqyzT1iTSlFY+O3FW8i+dwCfj8pKSnyWScQiRst7ULiRqQkbpxYzBP+mWeeycqVK/n6668B+Pzzz3n//fe56KKLANi5cycVFRWUlZWFtrHb7YwePZrVq1cDsHr1atLS0hg1alRonbKyMnQ6HWvXrm3xdd1uN06nM2yKpeTk5GBljijP/qyHm9jImXrreTzuiLu4VEodHmLU1E6lEu1B4kbLJG5ETuLG8UX+oOMkfvWrX+F0Ohk4cGDo+dP999/PpEmTAKioqAAgNzc3bLvc3NzQsoqKCnJycsILajCQkZERWudo8+fP5+6774712wnR6fXYUm34/X70+sg7dDAajTL6VYQCgUDENWaVUlgs0TXHEZ1H4kbLJG5ETuLG8cX8Cv9vf/sbS5cuZdmyZXzyySc899xz/Pa3v+W5556L9UuFmT17Ng6HIzTt2bMnti+gFDltaGbTXHu0LeNkdyfRBkif73DHGV38wO1qJG60TOJGZCRunFjMr/Bvv/12fvWrXzFx4kQAhg4dyu7du5k/fz6TJ08mLy8PgMrKSvLz80PbVVZWMmLECADy8vKoqqoK26/P56O2tja0/dHMZnO7jnCkaRoZGRl8vfVriKInpuAZpAWv19ul23nGglIKl8sV1e01t9tN7lFXeSL+SdxomcSN1pO4cXIxv8JvbGw8pv2jXq8PnaEWFxeTl5fHypUrQ8udTidr166ltLQUgNLSUurq6li/fn1onXfffZdAIMDo0aNjXeRWs1gsGAyRjb7UrHmM66ZG6UijNZqamkhKSop4O5/X26UHv+iqJG60TOJGZCRunFjMr/AvueQS7r//fnr16sXgwYP59NNP+d3vfsdPf/pTIPgDvvXWW7nvvvvo378/xcXF3HnnnRQUFHD55ZcDUFJSwoUXXsjUqVNZvHgxXq+XGTNmMHHiRAoKCmJd5IhkZKTT2NQU1VWB1WqlurqaNNV1B2eIBU3TcLlcpKWlRbRdc3vnpKQkDg+V1T4FFDEnceP4JG60jsSNk4t5wl+4cCF33nknN910E1VVVRQUFHDDDTcwd+7c0Dp33HEHhw4dYtq0adTV1TF27FiWL18e1ofx0qVLmTFjBueffz46nY4JEybw2GOPxbq4EdLIycll81ebozpwjUZj1H1rdydKKXxeH4YoOs/QGwwYDAYJjAlG4sbxSdxoHYkbJ6epLtrew+l0YrfbcdTWYLPF5laNUgqfz8cHqz8kPT094h+HUordu3fTq1eviLt9bC/NZSoqKursooT4/X727tlLr969IzrZ9vv9qECAkSNGxv2B63Q6sWdk4nA4Yvb7FG0ncaN1JG50nrbEjvj49SQIjWAzH4vFEnVXmdLM5uTcbjdmizniO2ve5udwCXDQiu5D4kbHkLhxcpLwI3G496zsrKyoOsNQSmG1WmWM65NobGyMrmtMt0eulkX8kbjRISRunJwk/AhpQFZm8MCN5vaP1WqVIS9Pwu1yhwYdaS2lFD6/j+SUZLr+ebpINBI32p/EjZOThB8ppUhJSYEoRsBq7rrR5XJLV5nHoZTC6/NiNBojCoyapqGhYTFbTr6yEB1N4ka7krjROpLwI6Vp6HQ6bHZ7VMNW6nQ6AgEZ7vJ4ou1RLDiymDFuKjUJEUbiRruSuNE63eNdxpqmkZOdE9UzteYKOD6frx0Klvg8Hk9UPWX5fD6Sk7rHbTmRoCRutBuJG60jCT8KmlJkpKfjdrsBIn5mJBVwjq95LOtIn3N6PB7safZuUdNWJCaJG+1H4kbrSMKPktVqxaA3RPVMzWq10tjYKM/jjqKUoqmpKbqath4PqSmp7VAqIWJH4kbsSdxoPUn40Th8NpiekY7X6424kojZbI66tm5XF+2tOb/fT3JycjuUSIgYkbjRbiRutI4k/ChpmkZOVjaNjY0Rb9s8KIicqYdr7tM6mp7IDAYDRmN0A5QI0VEkbsSexI3Wk4TfBmnpacFuGaNoZmMwGKLativzer0RH3zNB7vFbEHT6YKDXwgRxyRuxJbEjdaThN8GRoMRiyUJv7/1v5fmA9VkMtPY6IZOrh8aCIDLZe7037tSsHcvKGWPcEsNt9tHSoo9+EnK7U4R59oSN3Q6KwfrvEjcCFIKDh70YjKlRLhl94wbMR8tr7v517+GsGfvIaZN/RpNa31b0Lfe6sP27anceuvX6PWd1752/foMHl90Dvff9yUFBZ3Xk5fLpefXvxnB6DNq+elPd7Z6u0BAx6JFpzBsmJ2SX3eb41YkuGjjxt/+1pctX9u45+6NmEzRtT2PhXiJG263nt/MGcxppx7kRz/a0+rtumvckITfRr16JZOSbGXwIAOa1vrT3e3bbJjNBgYP0qPXd95pst1moqnRypjR/UlN7bwTD6U0Hl5gIT8vi6KipFZvFwholJSkkZ+nA7rHbTmR+KKNGxOuSGbvXiPDhw1Cp5O44fdrTL4ulX79zAwe1Pr+8Ltr3JDhcduo+dOL9AzxyE+9M88uoy1/vIiXzzFSMjxufEqUuNHZv/V4KQdEV5ZEjRvQttghV/htFO2PJV5+ZPFSjmglevlF9yRxI3aiKUs8lb8jSaU9IYQQohuQhC+EEEJ0A5LwhRBCiG5AEr4QQgjRDUjCF0IIIbqBiBP+qlWruOSSSygoKEDTNF555ZWw5Uop5s6dS35+PlarlbKyMrZu3Rq2Tm1tLZMmTcJms5GWlsaUKVNoaGgIW+eLL77g7LPPxmKxUFhYyIIFCyJ/d0KIuCBxQ4jOF3HCP3ToEMOHD2fRokUtLl+wYAGPPfYYixcvZu3atSQnJzNu3LiwcZwnTZrExo0bWbFiBa+//jqrVq1i2rRpoeVOp5MLLriA3r17s379eh5++GHuuusunn766SjeohCis0ncECIOqDYA1Msvvxz6OxAIqLy8PPXwww+H5tXV1Smz2axeeOEFpZRSmzZtUoD66KOPQuu89dZbStM0tW/fPqWUUk888YRKT09Xbrc7tM6sWbPUgAEDjlsWl8ulHA5HaNqzZ48ClKO2RimfVyaZ4mpy1NYEf58OR1sOwYQkcUMmmaKf2hI7YvoMf+fOnVRUVFBWVhaaZ7fbGT16NKtXrwZg9erVpKWlMWrUqNA6ZWVl6HQ61q5dG1rnnHPOCRvfeNy4cWzZsoWDBw+2+Nrz58/HbreHpsLCwli+NSFEO5G4IUTHiGnCr6ioACA3Nzdsfm5ubmhZRUUFOTk5YcsNBgMZGRlh67S0jyNf42izZ8/G4XCEpj17Wj+QghCi80jcEKJjdJmudc1mM2azubOLIYRIIBI3RHcS0yv8vLw8ACorK8PmV1ZWhpbl5eVRVVUVttzn81FbWxu2Tkv7OPI1hBBdg8QNITpGTBN+cXExeXl5rFy5MjTP6XSydu1aSktLASgtLaWuro7169eH1nn33XcJBAKMHj06tM6qVavwer2hdVasWMGAAQNIT0+PZZGFEJ1M4oYQHSPihN/Q0MBnn33GZ599BgQr3Hz22WeUl5ejaRq33nor9913H6+++iobNmzguuuuo6CggMsvvxyAkpISLrzwQqZOncq6dev44IMPmDFjBhMnTqSgoACAH/3oR5hMJqZMmcLGjRv561//yu9//3tmzpwZszcuhOg4EjeEiAORVut/7733FHDMNHnyZKVUsInNnXfeqXJzc5XZbFbnn3++2rJlS9g+ampq1DXXXKNSUlKUzWZT119/vaqvrw9b5/PPP1djx45VZrNZ9ejRQz344IMRldPhcEjzGpnidupuzfIkbsgkU2ymtsQOTSmlOuNEo705nU7sdjuO2hpsNltnF0eIME6nE3tGJg6HQ36fcUTihoh3bYkd0pe+EEII0Q1IwhdCCCG6AUn4QgghRDcgCV8IIYToBrpMT3tHa66L6HQ6O7kkQhyr+XfZRevMJiyJGyLetSV2dNmEX1NTA0BhUXEnl0SI46uvr8dut3d2McRhEjdEoogmdnTZhJ+RkQFAeXm5BNQIOJ1OCgsL2bNnjzRLikCkn5tSivr6+lCnMSI+SNyIjsSN6ETzubUldnTZhK/TBasn2O12+QFGwWazyecWhUg+N0ko8UfiRttI3IhOpJ9btLFDKu0JIYQQ3YAkfCGEEKIb6LIJ32w2M2/ePBnrOkLyuUVHPreuQb7H6MjnFp2O/ty6bF/6QgghhPhWl73CF0IIIcS3JOELIYQQ3YAkfCGEEKIbkIQvhBBCdANdMuEvWrSIoqIiLBYLo0ePZt26dZ1dpE511113oWla2DRw4MDQcpfLxfTp08nMzCQlJYUJEyZQWVkZto/y8nLGjx9PUlISOTk53H777fh8vo5+K+1q1apVXHLJJRQUFKBpGq+88krYcqUUc+fOJT8/H6vVSllZGVu3bg1bp7a2lkmTJmGz2UhLS2PKlCk0NDSErfPFF19w9tlnY7FYKCwsZMGCBe391kQrSez4lsSN1kmouKG6mBdffFGZTCb1pz/9SW3cuFFNnTpVpaWlqcrKys4uWqeZN2+eGjx4sDpw4EBo+uabb0LLf/7zn6vCwkK1cuVK9fHHH6sxY8aoM888M7Tc5/OpIUOGqLKyMvXpp5+qN998U2VlZanZs2d3xttpN2+++ab6zW9+o/75z38qQL388sthyx988EFlt9vVK6+8oj7//HN16aWXquLiYtXU1BRa58ILL1TDhw9Xa9asUf/73/9Uv3791DXXXBNa7nA4VG5urpo0aZL68ssv1QsvvKCsVqt66qmnOuptiuOQ2BFO4kbrJFLc6HIJ/4wzzlDTp08P/e33+1VBQYGaP39+J5aq8yxZskQBLU6zZs1SdXV1ymg0qp/97GcKUGeccYbavHmzAtTq1auVUsEftE6nU9u3b1dz585VgwcPViaTSWmapoYNG6ZuueUWtW/fPrVz587jvtbR086dOzv3gzmJow/cQCCg8vLy1MMPPxyaV1dXp8xms3rhhReUUkpt2rRJAeqjjz4KrfPWW28pTdPUvn37lFJKPfHEEyo9PV253e7QOrNmzVIDBgxo53ckTkZiR7h58+ap4cOHh/7+8ssv1aRJk1RBQYEymUwKUGPHjlVffvmlUkqF4sacOXPCjnW9Xq8KCgrU5MmT1fz585XNZgv7/Z977rlh6xuNRlVUVKSmTp2qysvLO/ptt0m8x40udUvf4/Gwfv16ysrKQvN0Oh1lZWWsXr26E0vW+YxGI3a7nezsbEpLS3nkkUeYOHEi69evx+v18sUXX1BUVMS6deswGAz06tUr9JmtXr2aIUOGcOWVV/Lwww9z9tlnM3fuXJRSFBUVsWzZMr7++muys7P585//HDaNGDGCrKysY+ZnZ2d38icSmZ07d1JRURH227Lb7YwePTrsc0pLS2PUqFGhdcrKytDpdKxduza0zjnnnIPJZAqtM27cOLZs2cLBgwc76N2Io0nsaNnWrVspKCggNzeXYcOG8c4773D99ddz8803A7Bt2zZOPfVUXn75ZQYOHEivXr3Ytm0bAOeeey69evVi8eLFXHTRRfzlL39h8eLFOJ1ONm7cGPY6PXv2DMWGxYsXM2HCBJYtW8bYsWNpbGzs8PcdK/EWN7rU4DnV1dX4/X5yc3PD5ufm5vLVV191Uqniwz333MP3v/99Dhw4wN13380jjzzClClT2LRpE0ajkXXr1vHPf/6TG264gaVLl5Kbm0tFRQVA6P+ffvopS5cu5Uc/+hGNjY3MmTOHn//85/z1r3/F4/GQnJzMj3/847DXffHFFzl48OAx8xNN82fQ0m/ryM8pJycnbLnBYCAjIyNsneLi4mP20bwsPT29XcovTkxix7FGjx7Ns88+S1JSEhMmTMBsNmMymZg1axavvfYaJpOJDRs2cPbZZ3PttdfyxRdfkJubi8PhACA9PR2z2czPfvYzfvazn5GVlcVDDz0EfHs8NbPb7cfEiOLiYmbMmMEHH3zA9773vY550zEWb3GjS13hi+MrKytj2LBhjBs3jjfffJO6ujr+9re/ARAIBEhPT2f8+PFceeWVLF269Jjtm5qaADjrrLOOWWaxWGSELCG6mIsuuoirrrqK1157Dbfbzd///nfq6+tDcQMgKyuLp556ikOHDp20EtnZZ58d0evn5eUBweQnYqNLJfysrCz0ev0xNUUrKytDP57uyuFwUF1dTXV1NT6fj+LiYrZt20ZeXh5+v5+LL74Yk8nENddcw9atWykvLw99Znl5ebjdbgCef/55lFKhz7i7fK7N7/NEv628vDyqqqrClvt8Pmpra8PWaWkfR76G6HgSO47vtddeo6ioiO9///uccsopobjh8Xioq6vjnHPOoaioiDfeeIPKysrQ0K2ZmZlhn+euXbtC/z76M/X7/aH4dODAAd59913mzZtHv379WrzISBTxFje6VMI3mUycdtpprFy5MjQvEAiwcuVKSktLO7Fkna+srIzs7OzQ9Pnnn5Ofn49erwcI3S4aO3Zs6MfV/JmVlpayZ88e+vXrx9y5cykuLmbSpElYLBaysrI67T11pOLiYvLy8sJ+W06nk7Vr14Z9TnV1daxfvz60zrvvvksgEGD06NGhdVatWoXX6w2ts2LFCgYMGCC38zuRxI6WORwO9u/fz/Dhw2loaGD79u3k5+dz2mmnYTQaQ5/XsGHD2Lt3L+Xl5fTr1w+Avn378sUXX/DZZ5/xj3/8g7vvvhuDwUBKSgqDBg0Ke52vvvoqFJsKCgo4//zzCQQCvPPOO2HPrRNN3MWNyOshxrcXX3xRmc1m9eyzz6pNmzapadOmqbS0NFVRUdHZResUzbX0b731VvXnP/9ZPfroo2rkyJHKZrOpqqoqddtttymr1aoKCwvVu+++qz7++GOVn5+vjEaj8vl8Sqlvm9d897vfVZMnT1Y5OTmhGrU6nU7NmDFDuVyuFl9//Pjxqnfv3h34jqNXX1+vPv30U/Xpp58qQP3ud79Tn376qdq9e7dSKti8Ji0tTf3rX/9SX3zxhbrssstabF4zcuRItXbtWvX++++r/v37hzWvqaurU7m5ueraa69VX375pXrxxRdVUlKSNMuLAxI7wv2///f/1N/+9jcFqHHjxqmysjKVlZWlqqqqlFLBZnm9evVS7777rrrooosUoE499dTjtgzKzc1Vdrv9mGZ55557rioqKlIrVqxQK1asUG+99ZZ69NFHVUFBgRowYEDo9eJVIsWNLpfwlVJq4cKFqlevXspkMqkzzjhDrVmzprOL1GmaD77MzExlMplUjx491NVXX622bdumfD6fys/PV1dddZWaNGmSstlsymKxqDPOOEMB6u233w7tZ9euXeqiiy5SVqtVZWVlqalTp6qnn35alZSUKED95je/afH1Eynhv/feey0GqsmTJyulgk1s7rzzTpWbm6vMZrM6//zz1ZYtW8L2UVNTo6655hqVkpKibDabuv7661V9fX3YOp9//rkaO3asMpvNqkePHurBBx/sqLcoTkJix7euvvpqlZubqwBlsVhCcaNZU1OTuummm1R6errS6/UKUF9//XUo5ixatEj95S9/USNHjlQ6nU5pmqZ++MMfKq/XG/Y65557rho8ePAxr//xxx8rQM2cObPd32tbJFLc6JIJX3yr+eA7so1ns3feeeeEbeWvu+66k+6/trZWpaWlqaKiohaXJ1LCF0IcKz8/XxUXF59wnaKiItWjRw+lVMsxx+fzqTFjxqiCgoJjEtnxEr5SStntdjVq1Kg2vgPRrEs9wxeRWbp0KTk5Obz00kvHTNdccw0vv/xyqHb+8aSnp9O3b18OHDjQQaUWQnSkiy++mJ07d/L++++3uPx///sfu3bt4uKLLz7uPvR6PfPnz2f//v08/vjjrX5tv99/TBezInqS8LuppqYm/vnPf3LxxRdz5ZVXHjPNmDGD+vp6Xn31VQA+//xzqqurj9nP7t272bRpEwMGDOjotyCE6AC33347VquVG264gZqamrBltbW1/PznPycpKYnbb7/9hPv5zne+wxlnnMGjjz6Ky+U66eu+9957NDQ0MHz48DaVX3xLGjh2U6+++ir19fVceumlLS4fM2YM2dnZLF26lKuvvpoVK1Ywb948Lr30UsaMGUNKSgo7duzgT3/6E263m7vuuqtj34AQokP079+f5557jkmTJjF06FCmTJlCcXExu3bt4o9//CPV1dW88MIL9O3b96T7uv3227nqqqt49tln+fnPfx6a73A4+Mtf/gIEm6Rt2bKFJ598EqvVyq9+9at2e2/djST8bmrp0qVYLJbj9mCl0+kYP348S5cupaamhgkTJlBfX88777zDu+++S21tLenp6Zxxxhn8v//3//jud7/bwe9ACNFRrrrqKgYOHMj8+fNDST4zM5Pvfve7/PrXv2bIkCGt2s8VV1xB3759+e1vf8vUqVNDzYL37t3LtddeC4CmaaSnp3Puuecyb948RowY0V5vq9vRlFKqswshhBBCiPYlz/CFEEKIbkASvhBCCNENSMIXQgghuoG4TviLFi2iqKgIi8XC6NGjWbduXWcXSQiRACR2CHGsuE34f/3rX5k5cybz5s3jk08+Yfjw4YwbN+6YUYWEEOJIEjuEaFnc1tIfPXo0p59+eqhXpkAgQGFhITfffHOL7TLdbndoCNfm9Wtra8nMzETTtA4rtxCtoZSivr6egoICdLq4Pe9OSJHEDokbItG0KXZ0Zr++x+N2u5Ver1cvv/xy2PzrrrtOXXrppS1uM2/evBP2Cy+TTPE47dmzpwOOqO4j0tghcUOmRJ2iiR1x2fFOdXU1fr+f3NzcsPm5ubl89dVXLW4ze/ZsZs6cGfrb4XDQq1cv9uzaic1ma9fyChEpp9NJYVExqampnV2ULiXS2CFxQySatsSOuEz40TCbzZjN5mPm22w2OXBF3JLbxp1L4oZIVNHEjrh8eJiVlYVer6eysjJsfmVlJXl5eZ1UKiFEvJPYIcTxxWXCN5lMnHbaaaxcuTI0LxAIsHLlSkpLSzuxZEKIeCaxQ4jji9tb+jNnzmTy5MmMGjUqNKTioUOHuP766zu7aEKIOCaxQ4iWxW3Cv/rqq/nmm2+YO3cuFRUVjBgxguXLlx9TGUcIIY4ksUOIlsVtO/y2cjqd2O12HLU1UvlGxB2n04k9IxOHwyG/zzgicUPEu7bEjrh8hi+EEEKI2JKEL4QQQnQDkvCFEEKIbkASPqAU+P3B/4vuQ6lvJyEi5fdDY2P3/P34fNDUlFjvXSkIBBKrzLEWt7X0O9Kq/8Hip3Tce89B7HZvm/YVCATQaTpIoA7UAoFAYg3goiCgIi+zCgTQNB1KKfwBHc//OYOtW/XYbFDYU3H2WIXLDQX5354I2GxgMoHFApoW/PfRpLO87sfng3vv07Hi3/DMUwfJye1eceNvf0viHy8n8Yenaki1JUYGffllO59/YWTOr2sxGAOt3u7IuKHpNExGIwaDAb3BgF6nR6/XBXu90+DoLzDevk5J+IDH4+VQY4AmtweTu20H7u7duyksLEyYBKqUYvfu3RQVFXV2UVrN7/ezb98+evXqFdF2+/buJTsnh4b6enx+I//5bxpffaXn0CENj0fjsksbWPluEunpGnv3aCggKSmY7DMzwGCEH1zu44sv9NjtkJoK+XmKHj3Aboe0NIXRAOkZYLV8e7KgaXJS0NX4/bDhSz8pqX78eGjqZnGjR6GRgQO/wY+PJndiJHy3x0udw0WTx4Mh0PqEf2Tc0BsMJCUl4ff78Pv9+H1+IBhHg8e5Dr1Oh95gwKjXYzAaMBoMGA+fJBiMRgx6PTqdDp1Od1T3uMGTBhUAjwfM5tjHDUn4wMiR9fz+0Sayc7La/AHX1taSkZGBXq+PTeHamVIqNBxoovD5fNTX10dc5vr6+tB3YzQa+ctffLhcPlwuDZcLMjJ07NrlIRCAHTs0XC6NrVs13G6NXbs09HpwOH1s+FJHZaWGz6cRCGi43cFbhRA8QK0WsCZBXi707at45P8CFBS0wwchOo3JBI8/dpAmdxO5ed0vbpSVKXr3Lqeg4JTOLkqrXXudj7PP2UNOTt+Ivq+j40ZaWlrYcg0NRfCkRykVvIPo9+P3+/H5fHh9PpoaDuH1+Qj4/fj9AQIB/+G7OsGrAZ0ueKJgMOh5770M/rQkkz8/76dvnxh+AEjCB0BDoemUXIV1MxZLcIJvr1CGDQtm7uHDm+cFfxRHPvebOdOF0wk+n4bXC4cOQW2thtOp8c03GtXVGgcPwuLFRj77XONnP9UoKEiMqyDROpoGZrPC45e4kSg0DXS6tl81tzRojXbEzXtN00Inbs3d3GiaxpFd3hz9t1KKQCCAz+fnP6vM7N2nMLRDdpaEL0QLjj6oj/yzpROFI/8dCMCDDxrxeIInChXh47gIIbqoY+OG1uplOl2wnsDkyfv44Q919CgoBGJ7xycxHhgJkSCUgo8+0rFokZFRowLk5iq2btO6dc1gIcTJKaUoLy9n6FAbp/T34vO1rV5ISyThCxFDDQ1w770mDAZ46CEPffsqqr/p7FIJIeJdfX09JpOJlJQUDEYjLrc75q8hCV+IGAkE4I9/NPLBBzqmT/cycmSArCzFV1uCzbiEEKIlfr+fvXv3UlBQgKZpWMxm3G43sR7qRhK+EDGgFGzcqPHoo0ZGjw7w85970eshN1exu1yj4VBnl1AIEW+CnQEpDhw4QEFBQaiyn8lsxu2SK3wh4o5ScPAg3H23CY8H5s3zkJoKoBgyJICmfdtsTwghIBg36urgjjtMvPZaBna7/fB8hdFoxO2RhC9E3AgEYPfu4FV9WZmVf/9bzw03eDnjjECoVr/NpqiqgkqpqS+EOMzphDlzjNxyi54//cmI3x8+zK3BYMDr9RHrvvqkWZ4QEfJ6YcMGHc8+a+CNN/TU1WkMHwZzfrOXG36egf7wabSmaWRlKTwe2L9PY1CJVNUXojtTSuHxeNi16yCfftKL71+k5+yz93DddZmhtvzNzfUCgQDB5r6xS/qS8IU4iWDFGY3GRli1Ss+zzxr4z3/06HQw7gLFlJ8GOHusYueuOlJS0sMa7ffsqTCbobqm88ovhOh4SqnmFI5C0dDQQPU332A0GBhcksfbb4HJpLFpswOzOSMsbgSTv0YgEIhp74uS8IU4juZEX/2NxhtvGvjTnwx8+aWOrCy4/ieKn00JMKgk2Mf+8aSlKVJTFXv3BZ/ZSa9sQnRtzYleQ8Mf8ONwODhYW0tqSgr9+/bB1DzAxon3gt6gx+fzScIXol2o4H8UEAhobN+u469/NfDSSwb27NHo1xfuvzfAVVcqCgsVOo3QgXu8m/VJSZCZqSjfrZ1gLSFEwjoibjTfjvf5/VRVVeFqaiQrI5NBAwegNxjQjmpmd9yIoGkYDAbcHg9mszlmRZWEL8QR3B6NTz/VsWSJgTffNOBywZjRirvnBRj/fUVaWnOOb92lutEYHFVv2/ZgJb8EGRtFCBEBry94Qu/zNlJTU4PP56UgLw97UW80ne7baNHKW3xKKcwWMy63C1uwyU9MxLyW/vz58zn99NNJTU0lJyeHyy+/nC1btoSt43K5mD59OpmZmaSkpDBhwgQqj6rGXF5ezvjx40lKSiInJ4fbb78dn/ReItqBUlBfD/96Vc9VV5m59FILb7xh4KILFcvfDPDGawEm/UiRnh75LXmDAXr3DlBdHRxoR7RM4oZINEpBTQ2s+0jHxIlmZt7mpaa6lp4F+QwaOJC09PTgELhR7t9kin1b/Jgn/P/+979Mnz6dNWvWsGLFCrxeLxdccAGHDn3b88htt93Ga6+9xksvvcR///tf9u/fzxVXXBFa7vf7GT9+PB6Phw8//JDnnnuOZ599lrlz58a6uKIbUwr279d48kkD48ZZmDzZzLZtem6eoXh/lZ/nnw1WxrNa2/bs/brrPFx37TcYT/Csv7uTuCEShVLB8eq9Xj833WTk+ust7N6lZ/gwG/379SE5ORlN09pUt17TNEwmE263J6ZPAmN+S3/58uVhfz/77LPk5OSwfv16zjnnHBwOB3/84x9ZtmwZ5513HgBLliyhpKSENWvWMGbMGN555x02bdrEv//9b3JzcxkxYgT33nsvs2bN4q677gpWejiK2+3GfUTfw06nM9ZvTcQZpVSLQ1WejN+vsW2bjuXLjfztbwYqKzUGD4LfPhzgh1cqcnODw2jGqJQUFsK/V2gcrIOszFjtt2uRuCE6SrRxo9lnn8GvfmVm1h3b+fkNPUhN0TFyJKQkg04Xm1q5SikMBgMetzumDfPa/Rm+w+EAICMjA4D169fj9XopKysLrTNw4EB69erF6tWrGTNmDKtXr2bo0KHk5uaG1hk3bhw33ngjGzduZOTIkce8zvz587n77rujKmOwx6O6Nv0ImtXV1VFbWxuTfXWUuro6qqurO7sYrRYIBDh48CA1NZG1dTt48CAmk4nXXrMxb14mgYCes85UPPZogPO+q7DZDjejifF3t2GDgccWZjH++37OPadtwaa7kLgR/7pb3HA6nbiamnA3eRkyqBcjhvelZw+F1nwJHuPvTqfTEUAB6nALn7bvv10TfiAQ4NZbb+Wss85iyJAhAFRUVGAymUhLSwtbNzc3l4qKitA6Rx60zcubl7Vk9uzZzJw5M/S30+mksLAwovLG8mBLlAO3eXCGRClvM03TIi5zIBCgsbGRrCzFz6akcPUPzZw6MlixLpKKeJEqKFDodLBnj9TUbw2JG/GvO8YNt8tFcVFv8vPyOO+7HfP+AwHV5jsSR2rXhD99+nS+/PJL3n///fZ8GQDMZnPUzRc0DdLS0sjMbPv91traWjIyMmLadrI9KaWora2NyXvvKD6fj/r6+ojLXFdXh91u57TTGhh/YQOZmbFr7nI8mqZRUKCw2xV79kJ7nVR0JRI34l93jBsGgwGz2dQhJznNr2EwGPD5fC0+jopGu/WlP2PGDF5//XXee+89evbsGZqfl5eHx+Ohrq4ubP3Kykry8vJC6xxd+7b57+Z1hGiTDsy7drsiP1+xc4ck+5ORuCHEt4xGIx5P7Jr3xDzhK6WYMWMGL7/8Mu+++y7FxcVhy0877TSMRiMrV64MzduyZQvl5eWUlpYCUFpayoYNG6iqqgqts2LFCmw2G4MGDYp1kYVoV2YzXHKJh779/J1dlLglcUOIYwVr6seuaV7Mb+lPnz6dZcuW8a9//YvU1NTQszO73Y7VasVutzNlyhRmzpxJRkYGNpuNm2++mdLSUsaMGQPABRdcwKBBg7j22mtZsGABFRUVzJkzh+nTp8e01yEhOoKmwfbtBrZtM3DbL/zIT/hYEjeEOJbJHOx8J1Y19WOe8J988kkAvvOd74TNX7JkCT/5yU8AeOSRR9DpdEyYMAG32824ceN44oknQuvq9Xpef/11brzxRkpLS0lOTmby5Mncc889sS6uEB2iTx/FRx9BYyOS8FsgcUOIY5lMJhyHGmK2v5gnfKVOXgvZYrGwaNEiFi1adNx1evfuzZtvvhnLognRKTQNRowI8Mor0NQE6emdXaL4I3FDiGMZDIbDz/Bjc43fbpX2hBDfCgRg61b4aotU3BNCtI5er8fn98esNa8kfCE6QEGBQq8H6chNCBEJFQi06g5Ya8hoeULEiNPp5Ouvv25x2aFDRrKyBnDwYGK0sxZCdIwTxQ2A2poaSgYOQBeD/r4l4QsRIzabjaI+xS12zNG/Pzz/fDmnjSgEJOkLIYJOFDcAdu7cEbPXklv6QnQAnQ4yM5uwWKRrXSFE55CEL4QQQnQDkvCFEEKIbkASvhBCCNENSMIXQgghugFJ+EIIIUQ3IAm/ncSqowTRjuQ7EnEmUeJGUxPU1Bi75yGUwG9a2uET/P7q6uqO2w4yEnV1ddTU1MSkk4SOoJSirq6O6urqzi5Kq/n9fg4ePBhxmevq6ggEAjQ2NpKbnRXs5F6IKHXnuPHsszaWLevHSy99g90e6OzitIrEDUn4IZqmxeTAbd5PLPbVURK1vJGWWa/Xk5aWhsFgSORjVsSR7ho3zjvPj8l0gJQUQ8KUWeKGJHwgeMJmt9vJzMxs875qa2vJyMhAr0+M3tSUUtTW1sbkvXcUn89HfX19xGVuaGggKysLo9GIFpPRpUV31p3jRkaGIiVlD7m5p3R2UVpN4oY8wxdCCCG6BUn4QgghRDcgCV8IIYToBiThCyGEEN2AJHwhhBCiG5CEL4QQQnQD7Z7wH3zwQTRN49Zbbw3Nc7lcTJ8+nczMTFJSUpgwYQKVlZVh25WXlzN+/HiSkpLIycnh9ttvx+fztXdxhYiYUopdO+HpZwrZvVuHUuqYyeWGlStz2LVbzrFbQ+KG6OqUUmz5Cv75chqHDmktxo1Y9+nXru3wP/roI5566imGDRsWNv+2227jjTfe4KWXXsJutzNjxgyuuOIKPvjgAyDYI9L48ePJy8vjww8/5MCBA1x33XUYjUYeeOCB9iyyEK3m98OOnfDCizqefU7HN9/YOfW0bbjd9WHruVwaf/97Lk8+mU9qcoB+fRO3a86OIHFDdGXq8H98Ph9//6eHJ57MZ9jwr+nVy3XMun6/nwank5IBA2Ly2u2W8BsaGpg0aRLPPPMM9913X2i+w+Hgj3/8I8uWLeO8884DYMmSJZSUlLBmzRrGjBnDO++8w6ZNm/j3v/9Nbm4uI0aM4N5772XWrFncddddmEym9iq2EMenFAoNrxc+/hj+9KyOf72qUV8Pp54a4L77vFx8cQFH9p3i9cLbb+t46ikLE65QTLhCkv2JSNwQXY5SwV6aFCgUbrebvfv24/Z4mDgxgx9cYaSwsHdY3FBK4fP5qDxwgMEDB6DTxabDn3a7vzh9+nTGjx9PWVlZ2Pz169fj9XrD5g8cOJBevXqxevVqAFavXs3QoUPJzc0NrTNu3DicTicbN25s8fXcbjdOpzNsEiJWlAJnvcarr2lc9gMd37tQzz/+qfGd7/h5+WUXr77q4tJL/aGDVilobIR77zXy298aePZPfhY/GcBmk4R/IhI3RFejtODteofTwZavt7Jt5y7saen0Lioir8BOUZHi6A4W3W43u3fuoldhT6xJSWgxChvtcoX/4osv8sknn/DRRx8ds6yiogKTyURaWlrY/NzcXCoqKkLrHHnQNi9vXtaS+fPnc/fdd8eg9EJ8KxCAqir4+z80/vSsjo0bITtbMXWqjx//2Ev//sGDtaU+tu+/38hTTxmZcIXisksDBC8wE7trzvYkcUN0BaHB9DQI+P3U1NRS+U0VFouV3Pz8YBe9J+iUv6mxiR07tjO4pASL1RqMGDHqxD/mCX/Pnj384he/YMWKFVgslljv/rhmz57NzJkzQ387nU4KCws77PVF16FUMNFv3gx//ouOv72ksXcflJQEuPdeH5df7qegQLV4DCoFbg88tdiA2+Vl0UI9V12pkLvJJyZxQ3QFSik++ljjzTdh4jV78XodpNps9C4qRqfTnTDRKxRul5t9e/cwdPAgLBZLzC8PYn5Lf/369VRVVXHqqadiMBgwGAz897//5bHHHsNgMJCbm4vH46Guri5su8rKSvLy8gDIy8s7pvZt89/N6xzNbDZjs9nCJiEioVRwnO9V/4NJ1+o457t6Hn9Co28/P3/6k5u333Zx000+evQ4frL3euGX/8/Eb39rok8fC9f/RJGS2vHvJdFI3BCJSjVPStHY2MjatTWsWAmaLoXiPn3Jys5Bpz9+sleHbwm4XW5qq6spKRmIxWptl2F4Y36Ff/7557Nhw4aweddffz0DBw5k1qxZFBYWYjQaWblyJRMmTABgy5YtlJeXU1paCkBpaSn3338/VVVV5OTkALBixQpsNhuDBg2KdZFFd6UALZioHQ54402NPy3R+HC1RlISXHKJj+uu83HqqQGMxhMff837uPNOExs36pn/QICf/qTlEwNxLIkbImEcjhsQvBO4YoWG2XKI7Jzd6PUGfjgxm4k/cmO1Wo84/o+T7A//v6GhgZrqb+jfty8Go6HdHvzFPOGnpqYyZMiQsHnJyclkZmaG5k+ZMoWZM2eSkZGBzWbj5ptvprS0lDFjxgBwwQUXMGjQIK699loWLFhARUUFc+bMYfr06ZjN5lgXWXQzVVUmki0G0tJgz57Dz+eX6Pj6aygsVNxyi5cf/chHcbFCpw8e3Sc7AB0OmDzZzP/+p+eR/wsw7WeBhBknPB5I3BDxSilwu494Nk8wUft9Pg4cqOW+B9Lo31/P7x4pxGA4nFK1I84KTrx3nE4n+/fuZfiwoRgMhnYdgrdd2+EfzyOPPIJOp2PChAm43W7GjRvHE088EVqu1+t5/fXXufHGGyktLSU5OZnJkydzzz33dEZxRRfi9cIdd2Ti9cLQIfDyyxrfVMPgwQEeecTH+PE+srM56Zn5kerrYd9eF3l5Go8/ZmbSj5Qk+3YgcSM+KAXV1RqVlVb69uWYGuZdza5dBn76UwM3TNNz8Xgdbo+b/QcOUH/oEOlp6Tz3fACzWcNoNEa0X6UUDfX1VFVUMGL4MPR6fbvHDU0p1SXbCTmdTux2O47ampM+l6uurmHvgQOkp6e3+XV37txJ79690ekSo0c1pRQ7d+6kT58+nV2UVvP7/ezZs4eioqKIttu7dy/5+T341a8yeOmlVFJS4Jxz/PzkJz7OOcdPcnLkj83KyzVmzjRxsDbAirchJUVr1UHrdDqxZ2TicDjkuXEckbhxcj4f3HBDDl9+aeLFFysoLk6MngyjjRsff7yfBx8sZtOmbG65uZIf/7iWzKwsUlJSok7QSikONRyi3llHcVHRSSv0HaktsaNTrvDjkaa1LlC3dj+JdIWXqOWNpsyBgI8f/tBBXh5cfbWRwYMDGAyRX5E3V9D74AMfX35p4d57NJKSFFrMO8MU8aw7xg2DAaZN87FxYx0FBSREmSH6zzgvL8DChR7uv9/F8BEp9C6K/gS9+fra6XDQ1NhIn+LiYJmi3mNkJOETvKqz2+1kZGS0+cdbW1tLRkYG+gS5z6WUora2lszMzM4uSqv5fD7q6+sj/r6atzntNAdjxjiPuDKLPNl/9rmO++410qvQxbrVfnJzNTRNtUvNWhGfunPc+P73Ff37V9CjxymdXZRWa0vcyM9P4dFHqzCbjWhadHd0mnvG/6aqikMNDQwqGfhtOToobsT//aMOlChnqiKos76vgFI8vMDAJ5/oOetMK3l5oGny3L67ku89sUT7fbX5aYuCqqoqGg8dCkv2Hfn7kSt8IVpJKdiwQcf27U389PpG/t9tGZw9VhK9EOLElFIcrK1Fr0HJwAGd9vhGEr4QraAU7NmjsWiRjl0703jnbT9WiyR7IcSJKaWorq7GqNfR83Avjp0VN+SWvhAnoRT85z86LrvMAkrPS38NYLV0XEUbIUTiaR7Tfk95OZoKUJCfj0bnjqYhCV+I42iuUfvJJzpuuMFMQb7Gr2ZBXt7h2vhydS+EOMqRLd137dyJ1WyiV2Hht4m+E+OG3NIX4jiU0nC5FFu2NNC7t5mnn/LTv5+K6ehVQoiuRTs8HG7FgQOkp9kpyM8/cmHnFQy5wheiRYEArFql48ILzQwfamDlOwH69zv87E2SvRCiBc238SsrKki324K38Zsr6MVB3JCEL8RRfD7417/0TJ1qpncvPb0KU2mnwauEEF2IUoqdO3ZgS02JSf8MsSYJX4gjKAV//rOBG280k5Gu8cj/BTjOyKpCCBHi9/vZtnUrWZkZZGVmxl2yB0n4QgDBM3O/H956S8///Z+RM0sVb73p53ArGiGEOEZzBb2AP8Ce8nJ6FhSQl5sbt7cDJeELAYDGiy8amDbNzLCh8JfnA/TsEbfHrRAiTvj9fg4c2E/PHgVkZWV2aN/4kZKEL7o1pcDvB4/Hi0YVP71e8YenA2RlSbIXQhyfUgqfz0d5+W7yc3OwpabG5W38I0mzPNGteb1w331GDh508X8LkklLCwCS7IUQx6eUwuv1svXrrxnQv1+bhsrtSHKFL7otpRTvvadj8WIjBXnp2O22YE9Y8X/cCiE6SfOV/batWxk44BRsNjvxexM/nFzhi27J64UFC0yYjA3838NGfnQN6GR4WyG6pCM6v0O18TD3+Xwc2L+fIYNKsFitaG3dYQeShH9Y7L6uxPjiuzO3W+Opp0y8846BG6bauWGaOny8yncnItMdfzFKQU2NRkODsc3Js6Ns26bxj3+Y0DQD+fkGJk3yoddHtg+Hw8i+fTp699pP/75FmMymhOt1s9snfKVg334TX2/zcurIKtDUyTc6joYGA08+2Ysrrmikf//GGJayHSlFbW0NlZWVnV2SVtLYujWDxkaNlJTWl1kpHTt26FHKwRNPZPPnP1t4+CHF1J+pRDpeRRxRQE1NDf5AoM37qqmpISUlBV2bB11vfz6fxo035lFVdQpLllSSkeHt7CKd1Jo1Bp55xoTdfoic7IOcd14jRmPrtq2uriYQMDNrVi82b9Kz5sMMTGZDQp7sdfuED/DCCzb+8Ccrzzz9KVlZnqj3U1Vl5m9/Ow29roYf/WhfDEvYfpSCyooKzKZW/vo7mculZ8aMHAyGnixc+CUWc+uC7a5dVm6+ZTh33LEbo9HFnb+xMuWnKuKzfCGaWcxmDuzfR2NjQ5v39c03leh1YDDEf0hWSmPsWYp//COTXTv342pydXaRTqpkIDzztB9nfQ25OS6+qWr9SdqB/fswGJLJysxm2rQUcnISM9lDOyX8ffv2MWvWLN566y0aGxvp168fS5YsYdSoUUCw0sO8efN45plnqKur46yzzuLJJ5+kf//+oX3U1tZy880389prr6HT6ZgwYQK///3vSUlJiWlZNQ0GD4a6OjOVVdn06VMf9b4MBh2ZmT527cogJaWeBDhZRylFSkoyNputs4vSKklJkJ4eQAUMpKelYjSe/I6MUgqHw05Tk5G+fZP42RQ/mRkKXaIetV1UIsUNgKSkJGx2G6ltbI6lgCyXC5PJRHJyckLU9v7BD+oYPnwjffv2RNNMnV2cVtG0OlJTM0hPb91n3Nypjs1mIz8/nUcecZGVkZwQcf14Yl70gwcPctZZZ2E0GnnrrbfYtGkT//d//0d6enponQULFvDYY4+xePFi1q5dS3JyMuPGjcPl+vZMcdKkSWzcuJEVK1bw+uuvs2rVKqZNmxbr4gJw+umK5GT46KOUsModkbJYAvTp42L7DgtudwL/KuKUUorGRj0VB0z07evCYGj9l7V1qwWrVZGf5yU5ySq38eNMIsYNTdOwpdrw+Xxt2w/Bk4empqbYFKwDaBoYDL6EOI6aB7RpamrCarVGtK3f78dkNhEI+ElJtqIleFiP+RX+Qw89RGFhIUuWLAnNKy4uDv1bKcWjjz7KnDlzuOyyywB4/vnnyc3N5ZVXXmHixIls3ryZ5cuX89FHH4XO7hcuXMj3v/99fvvb31JQUBDTMvfuBQMHwPr1KXi9GiZTdFlf06BkYBNr16ZSU2OgZ8/oHw+IllVWGqmuMdC/f1MEwUZj+3Yr+fl+CgpMmM2WhL0l11UlYtwAyM7OZvuO7dhstjZdmVssFg4ePBjDkomjeTweTCZTq78nTdNwuVxYLFaSrEldIm7E/Hzl1VdfZdSoUVx11VXk5OQwcuRInnnmmdDynTt3UlFRQVlZWWie3W5n9OjRrF69GoDVq1eTlpYWOmgBysrK0Ol0rF27tsXXdbvdOJ3OsKm1zGY491zF9u0WKiqif5ataTBwYCNut46KisS4zZVodu6y4Pdr9O/vCt1yOxmvV2N3uZmiIg9JSRq6RLgs6WYSMW4AZGZk4PO27QofQK/X4/XEf+W3hKWCJ406na7VcQOCv4/k5CR0Ol2XiBsxT/g7duwIPVd7++23ufHGG7nlllt47rnnAKioqAAgNzc3bLvc3NzQsoqKCnJycsKWGwwGMjIyQuscbf78+djt9tBUGMGoJ5oG3zlH4XLp2bQ5qU239Xv3dpOT3URjoxbRD0u0hsaO7RZSU/306OFu9VYOh579+00UFblJTjp8S0++m7iSmHFDw2QyYbFYWr3Nifal1+sJBAISN2JM0zS8Pi86XeQ1dN1uN2aTiSRr14gbMU/4gUCAU089lQceeICRI0cybdo0pk6dyuLFi2P9UmFmz56Nw+EITXv27Ilo+2HDFJmZsG5dapvKkZPjJSvLz6pVdrpnK932EwjA5q+s5OR4sdn8rb41V1Vl5NAhPUOH+LBaLcHtusDZeleSqHEDICMjA4+n7Y/vLFYLLrc7ISrtJRqXy0XS4ZP91n6+SgVjjsVq7TJxI+YJPz8/n0GDBoXNKykpoby8HIC8w4OLH93uu7KyMrQsLy+PqqqqsOU+n4/a2trQOkczm83YbLawKRK5uTBiuOKzz5Jpaor+Y9HrFWlpAb7akoTXm9g/jnjT1KRj504L/fo1RVTPYvduC5oG/fopDPr4b/bUHSVq3ADIzsqmsbGJtl77Wa1WmhoTpP+OBNJcYS8pKSmikymlAoDCaDR2mbgR84R/1llnsWXLlrB5X3/9Nb179waCFXHy8vJYuXJlaLnT6WTt2rWUlpYCUFpaSl1dHevXrw+t8+677xIIBBg9enSsiwwEE/X55yn27TOze7c56v3odNCnr4u9e03U1naNH0m8qK42Ul1tpGRg62szKwVfb7ViS/VT1FvqVcSrRI0bADZbKioQaPP9PIvFEtbiQMSO2+3GbI4srnu9XkzmI27ndwExT/i33XYba9as4YEHHmDbtm0sW7aMp59+munTpwPB2ym33nor9913H6+++iobNmzguuuuo6CggMsvvxwIntlfeOGFTJ06lXXr1vHBBx8wY8YMJk6c2C41bSF4833sWIVSGp9/kRz1oxpNgyGDG2ls1FNZmRid2SSKfftM+HwapwxofQ19pWDnTjOFvfzk57X9WatoH4kcN/R6PUlJSfj9/jbty2Aw4PX65Bl+O/D7/RH3Yuh2u0lOSiI5KbmdStXxYp7wTz/9dF5++WVeeOEFhgwZwr333sujjz7KpEmTQuvccccd3HzzzUybNo3TTz+dhoYGli9fHlb5ZenSpQwcOJDzzz+f73//+4wdO5ann3461sX9lqYx4BTo2TPYHr8tvWUWFrrR6RRff911zgw7m1Kw+askzOYA+fmtf17a1KRj924LAwboSEoyyvPROJXIcQNNIzs7u81X5zqdDk3TCMSgq17xLb/fj16vj/jYb2pqIiMjA3METfniXbvcc7744ou5+OKLj7tc0zTuuece7rnnnuOuk5GRwbJly9qjeMdlt8OZpYoV/06mrs5AZmZ0zW1yc73kZHvZs8ecMINLxDul4KuvrOTlecjMaP33UldnoKbGwIhhra/kJzpHosYNTSmys7IoLy8nObltV4MmkxGPx4PFYpHfa4w0NTVF3JKiebz79LT0k6+cQBK836DY0jTF976nqK42snVr9FfnKSl+fvCDA+j1njbdKRDf8ng09uwx06+fC3Mr+88H2F1uxuXSUzJIfuqifSiCPeVF2sa7JYnW4168O7LCXqTfTUAprEld6y6tRMGjjD7cze66ddF3s6tpcLAuidffyKWuTiruxUJdnYGKChN9il0RPb/fvdtMUhIMPCXxm9SI+KVpGqm2VHy+6J/BK6WwWq1ScS+GNE0LVdiL5I5JIBDAYrZgMZm7VNyQhH8ETdPo1QsGDID1n6RE3axO0+CU/k04HQapuBcjLpeOzMxDlJ5ZH9Hxt32blZwcyMoO3noVItaa22fnZGfT1NQU9a14TdMwGo0xadMvgpRS+P3+iEch9Hg82G324LP/LhQ3JOEfxWyG0jGKXbss1NREf3U+alQDp42qQB/BAC/i+DZuTKK+3kJmBGNv+3wa27Zb6FMMyUl0qTN1EV80ICM9A6/X26bb+s2V9qSmfmxEUzu/+TFAWnpal+hs50iS8I+iafC9MoXHo2PXbkvUB15SUoDy8gzeeCMj0Xtj7HRKQe1BHeec/Q3Z2a1P+I2NOioqjAwbJuPei/ZnNpsxGoJ39NqSsM1mM16v9KsfC263G6Mx8tY5Ho+H1JSULpXsQRJ+i04fpcjO0li7NpVou8e1WgNkZfn46isrbWye2+15PBrLl2dS9U1qRMdfZaWRujoDJQPljEt0AE0jKysTt7v14zy0xGq10tTUJFf5MeByuUhOTo74s/T7/dhSU2lz94lxRhJ+CzIzYcQIxf/+Z4u6m12DQTHglCYOHDC1qateEaywt3+/iQEDmojk7tyevWZAR0mJQutqR66IOxrEpD2+1ZpEU5NLmuXFQDRN8iDYmZLZbO5ycUMyUQt0OjjjDMW+fSb27o2+O9Y+fVxUVxupqpIuXduioiI4+E3JwMbIetjbYcFmg8KedLlbcyI+2W32NvW4FxyBz4jb7epiqabjKaXw+XwR39L3+XykpKQGn/13sbghCb8FmgbnfVcRCOj45JPomudpGvQ/pQmfT6O8PPq++bs7pWDbdis6naJ379bfKlUKvtpiJT8P0tLar3xCHEmv15NkTWpTb3mhSmZyS79Nov0O3G43WZkZXXKwU0n4x3FKfygogM8+i75f/R4FHpKT/Xy91SLHbhts3mwlPd0XUYU9j0dj714zgwYpYjBcuRCt1nxbvy3P4PV6vVTcayOPxxNx+3sAl9tNWlpal3t+D5LwjystDc77juLrrVYOHYruY7LbffTt24SjTqqIR8vn09i+zUqvXm6Sk1t3q1QpheNwHwiDShSa1gWPXBGfNI2szEzcrugr7mmaFuqARyruRae5aZ01gpHumj9rn9dLakpqV7zAl4R/PJoOLr9MkZnpxuOJ7mMymxWjTmvgy41JUnEvSg2HdBw4YGLAKU0RNa07UGEKPvcv6ZJ35kQcS0lJQaeL/lfX3OOedLHbNi6XK6KED8HP3mAwRDyUbqKQLHQcGnDmmYrGRivvvJMW9S351NQA27cnUfWN9LgXjQP7TRysM9C3b+u71AXYvs2C0aAx4BQZvUh0HI3gFbrd3rbKexaLpc3N+7o7r9eL0RhZ3A0EFMlJyV2uw51mkvBPIDkZsrNM/HeVHZ8v8i9f02DAgCY8Ho19+6SmfjS2bw/Wf+jXL5KmThrbd1jIzoH8/HYrmhAt0zSysrKjvkLXNA2dTofPF91onSJ4pR4cqTSyuO31erCl2tqpVJ1PEv4JmEwwfLhi8+Ykqquj62a3oMCDxRLg6y1WqbgXIaXAZPYz6rQaCgtbf7UTCMCuXRaKeitSU9uxgEIcR0Z6Rpue4wMYDIY23SXozjweDwaDPqoe9kJd6nZBkvBPRIOzxyoaGvR8sSG6ca7T033k5HjZ/FWSJPwIBQLwzjsZpNo0UlJaH/gOHdKze7eZ/v0hwjEzhIgJi8WMyWRqU6U7i8UiI+dFyeVyRTUkrs/rC3ap20VJwj8BTSnGjFZkZxN1e3yLJUDfPi527TLj8XTNs8b20tCgZ/PmJCLt0vrgQQN1dQZOHSlnWKLjBUdX08jMyIh65DtN00hKSpKKe1FqrqEfzZV6ND3zJQpJ+CeiaeTkwLChio8/Tomqpn3zc/yqqmC/7qJ1lFJUVhqprTVQUtJIJI1i9+414fXqOOWULlnvRsQ7TQMt2B6/LQnbbDZLwo9Q8xW9x+OJ6g6LyWRE34VH2pKEfxJ6PZx7TrCb3T17Iq94p2nQp6+LQ4f00uNeBDQt2HFOIKBxSv/WB73mnvmSk6F3b7nCF51EKexpdgL+6Ie6bX6GL23xW0/TNJRS+AOBiIfF9fv9JCd3vRHyjiQJ/yQ0FN/9TrCb3U8/i+62fnGRC6Mx2ImPHLutoxRs/spKUpKf3NzIehzbscNCQQHk5LRT4YQ4CQ0w6A1YrdbDNcYjP/A1TUOv10vFvQh5vV6MUVTe8Xg8wRHyurCYJ3y/38+dd95JcXExVquVvn37cu+994b94JVSzJ07l/z8fKxWK2VlZWzdujVsP7W1tUyaNAmbzUZaWhpTpkyhoaEh1sVtlVNOgYJ8+GR9dAk/O9tLdraXbVsj6wSiOwsE4KuvkijI95CW1vrmSR6PxvbtFoqLFNau+yiuy+mKcUMDMjMzo654p5TCZDLh9njkKj8C0XS4A8GEn5qa2qXHMIh5wn/ooYd48sknefzxx9m8eTMPPfQQCxYsYOHChaF1FixYwGOPPcbixYtZu3YtycnJjBs3LuzAmDRpEhs3bmTFihW8/vrrrFq1imnTpsW6uCenadjtMGqUYvsOCy5X5B+ZxRKgsNDN11steL1d93ZRLLndOvbuNdH/FBcmk2p15ZuGBj2VlUaGDyOioXRF5+qKcQNNIyc7m8bGxqhuE2uahjUpCVdTU5dtJhZrSikaG7+tsBfJ5xbw+0lJSenSn3XMQ+KHH37IZZddxvjx4ykqKuLKK6/kggsuYN26dUDwC3n00UeZM2cOl112GcOGDeP5559n//79vPLKKwBs3ryZ5cuX84c//IHRo0czduxYFi5cyIsvvsj+/ftjXeST0ungsksVe/ea+eqryM8cdTooKWmkosJEnfSr3yrV1Qaqqoz07RtZpaVvvjFSX29g0CDVlR/FdTldMW4AJCcnByuBRXnVaD3cNE+u8FvP43FH3DWuUurw0MRdu4O0mCf8M888k5UrV/L1118D8Pnnn/P+++9z0UUXAbBz504qKiooKysLbWO32xk9ejSrV68GYPXq1aSlpTFq1KjQOmVlZeh0OtauXdvi67rdbpxOZ9gUK5oGI0cqjEaNdetSIz52NQ1O6R+suFdV1bV/ULGya7cFt1tH/36Rdam7Y4cFpTT69pUAmUi6YtwA0On12FJtUVe+MxqNMmpehAKBQMQ17ZVSWCzRNeNLJDFP+L/61a+YOHEiAwcOxGg0MnLkSG699VYmTZoEQEVFBQC5ublh2+Xm5oaWVVRUkHNUjSuDwUBGRkZonaPNnz8fu90emgoLC2P6vop6B4fM/ejjlKi62Q32FKfYuk0eLLdG+W4zycl+evVufW9lSsH2HRYyMoLfl0gcXTVuoBQ5bWie11zrPNqx3bsbv9+PXh95D3s+3+EOdyThR+Zvf/sbS5cuZdmyZXzyySc899xz/Pa3v+W5556L9UuFmT17Ng6HIzTt2bMnpvu3WmHsWMW2bdaoutnNy/OQnu7jq83S497JKAV6g5dLLt5Pbk7rOy5RCrZutdKrEGz2diygiLmuGjc0TSMjIwNPlAPhBK88LXKV3wpKKVwuV1S35d1uN6m2rl1DHyDmPcHcfvvtobN1gKFDh7J7927mz5/P5MmTycvLA6CyspL8I0Y2qaysZMSIEQDk5eVRVVUVtl+fz0dtbW1o+6OZzeZ2HdJQ0+D88xRPPKlnw5fJ5OfXRbR9SoqfXr3cfL3Vis+nYTRK1j8el0vj5X/mUlzsRqerbfV2breOfftMnDNWYZYnJwmlq8YNCPbcZjBEN1qmpmnBoXIbm7p0D3Cx0tTURFJSUsTb+bzeLj1oTrOYX+E3NjYe0+GBXq8P3ZIqLi4mLy+PlStXhpY7nU7Wrl1LaWkpAKWlpdTV1bF+/frQOu+++y6BQIDRo0fHusitNnKEIi0N1kfRPE+vh1NHHsLlUlE9EuhODtYZqKg00a9/U0R32GpqghX9BpYoIumZT3S+rhw3ADIy0qPuZtdqtdLY1CgV905C0zRcLlfEJ0bN/SQkJSV16SZ50A5X+Jdccgn3338/vXr1YvDgwXz66af87ne/46c//SkQ/FJuvfVW7rvvPvr3709xcTF33nknBQUFXH755QCUlJRw4YUXMnXqVBYvXozX62XGjBlMnDiRgoKCWBe51XJygkn/66+teL0aJlPrfxyaBqNOr+elv6dTXm5mwADpMvN4Kg6YcLl0DBwQWcI/cMCE261j6JDWN+MT8aErxw3QyMnJZfNXm6O6m2A0GqM+WehOlFL4vD4MUXS6ozcYMBgMXT5uxDzhL1y4kDvvvJObbrqJqqoqCgoKuOGGG5g7d25onTvuuINDhw4xbdo06urqGDt2LMuXLw87M1u6dCkzZszg/PPPR6fTMWHCBB577LFYFzciRqNi3AWKO+dZKS83RzhGO6SmBDjUYGT7dosk/ONQCrZssWLQK3r0iKzC3u7dZiwWjT7FUsEp0XTluAGKNLudQCAQav4Vieb25NFs250EQt3pRvYZBQIBkqN4DJCINNVF7xM5nU7sdjuO2hpsthg9m1GK9z/UKLtAzy//316uuqo6oivQ2loDV08cwLhxdfy/mfviokKoUordu3dTVFTU2UUBgol73l29+OyzZJYt3UJKSuuSt1Jw3/2FfPpJJh+t9ZOe3s4FbSOn04k9IxOHwxG736dos/aKGwpY+9E6LBZLxH28A+zbt4+srKx2r2/QWvEWNyD4WMjpdB63vsbxuFwuMtLS6duvX4SnCp2jLbFD+iKLhKYxqCTYze5HH0f+HD811U+vQjc7d5qRVjYt83g0tm2zUFTkxmpt/Yfk90N5uZn+/RVdvDtskWgO97qXnZUVVSc6SimsVmvUXfR2F42NjdF1qev2dJuTbkn4EUpLgzFjFBs2JON0Rta5g8Gg6F3kZvduC42N0uNeS+rr9cGKdwMaI+oa99AhPfv2mRg4MFhBUoh4ogFZmcGEH81teavVKkPlnoTb5Q4NVtRaSil8fh/JKckJcXXfVpLwI6RpinPPUVRXG9i5K/JmMmee6cRicePxdIefV+T27TPhcBjo0yeyHvaqq40cPGhgyGAV6SM8IdqfUqSkpARv70d4hd/c5avL5Zaa+sehlMLr82I0GiM6odI0DQ0Ni7l7NHmUhB8hTdM444xgN7uffZYc0W19TYNevdxUVlqj6pO/q2vuOEevV/TpE9nty337TAQCOkpKlOR7EX80DZ1Oh81uj2q4W51ORyAgw+QeT7Q9EQZHJDRGVa8iEXWPdxlj/ftDv36wZk0qkR67hT09nHVmJW53l2/yGZXNXyWRkeEjN7f1PYs11+xPToaePduxcEK0haaRk50T1bN4TdMwGo34fK0fKro78Xg8UfWw5/P5SE7qHrfzQRJ+VJKT4Mwxiq1brdTUGCO6zabTKcr3pPOvV7Mk4R/F7w82revd201KSuvPpJSCHTst9CqErMx2LKAQbaApRUZ6Ou7D3exG+qxZKu4dn8vlCg2JGwmPx4M9zd7l+9BvJgk/ChqK731P4XQY2LgxsvabJpOiuNjF7l0Wmprk4z+Ss15PebmZ4iJXRBX2PB6N7dst9O2rkN5HRTyzWq0Y9IaonsVbrVYaG6XHvaMppWhqaoquhr7HQ2pK92nWIxknGprG6acr0tJh7dpUIq0lVjKwieoaA9U10fWv3VXVOw243TB4cGNEJ9xOp57qaiMjRqjucqIuEtHhH2d6RjperzfiymVmsznqWv5dXbS39P1+P8nJye1QovgkCT9KuTlQUgIbNybh9UZy4ELfvi7cbh3l5fHRiUa8qD1ooKSkhjFj6iParqLCxKFDekoGdps7cyJBaZpGTlY2jY2NEW/bPLaAXOGHa+4LP9ITIaUUBoMBo7H7XHhJwo+S0QiXXhJgz14zBw5EdmZZVOQiI8ND3UG9HLyHKQX/ec/Otm2RPYRXSrFzpwW9XqNfPyU1IUXcS0tPw+/3R9U8z2AwRLVtV+b1eiNO2s0nCRazBU2n6zZxQxJ+lDQNTjtV0dio57PPW988TylFdraXgQMPsWFDEkrJJSlAIBBsktejh4fU1EiaPmjs2GkhKxN6FCCX+CLu+bxGXnppAF98EVncAEK39cW3mppcEQ+JGwho7NhhwGjMCD6Q7SZxI+aD53QnQwbDqNN81Nc7cDjqWr2dUqBp+Xz+RRLV1U5Mps7rZ1epYJeUdXV1nVYGgKYmPfsP6Bk69CCHDh2ktXc8lYLa2hxKSqRLXZEYXC6Nt9/uyZavDzL3zg1oWuuPf6/XS3V1dac3z4uXuAFQU1NDcnIyDoej1dvs3JnMrbeN4I5faowY3m3yvST8tsjMVCx/K4DblY9OlxfRCOwzb01m714jw4cNQqfr3NtJgwcN6vSKQEppPPZ7I/l5aRQVDY5o28VPWDEaAnSjR3EigaWlKX5xSwCnM/XwsRfh8R+8YmifwkUgHuIGENXz+16Fem65Wc9553WPW/nNZLS8TtL8qcfB8SI6gYyWF586Km7I8d/5EvU7aEvskCv8TpJoPzIhROzI8d/5uuN3IJX2hBBCiG5AEr4QQgjRDUjCF0IIIboBSfhCCCFENyAJXwghhOgGIk74q1at4pJLLqGgoABN03jllVfCliulmDt3Lvn5+VitVsrKyti6dWvYOrW1tUyaNAmbzUZaWhpTpkyhoaEhbJ0vvviCs88+G4vFQmFhIQsWLIj83Qkh4oLEDSE6X8QJ/9ChQwwfPpxFixa1uHzBggU89thjLF68mLVr15KcnMy4cePCuoOcNGkSGzduZMWKFbz++uusWrWKadOmhZY7nU4uuOACevfuzfr163n44Ye56667ePrpp6N4i0KIziZxQ4g4oNoAUC+//HLo70AgoPLy8tTDDz8cmldXV6fMZrN64YUXlFJKbdq0SQHqo48+Cq3z1ltvKU3T1L59+5RSSj3xxBMqPT1dud3u0DqzZs1SAwYMaHXZHA6HApSjtkYpn1cmmeJqctTWBH+fDke0h1/Ckrghk0zRT22JHTF9hr9z504qKiooKysLzbPb7YwePZrVq1cDsHr1atLS0hg1alRonbKyMnQ6HWvXrg2tc84554SNbzxu3Di2bNnCwYMHW3xtt9uN0+kMm4QQ8U/ihhAdI6YJv6KiAoDc3Nyw+bm5uaFlFRUV5OTkhC03GAxkZGSErdPSPo58jaPNnz8fu90emgoLC9v+hoQQ7U7ihhAdo8vU0p89ezYOhyM07dmzp7OLJISIcxI3RHcS04Sfl5cHQGVlZdj8ysrK0LK8vDyqqqrClvt8Pmpra8PWaWkfR77G0cxmMzabLWwSQsQ/iRtCdIyYJvzi4mLy8vJYuXJlaJ7T6WTt2rWUlpYCUFpaSl1dHevXrw+t8+677xIIBBg9enRonVWrVuH1ekPrrFixggEDBpCenh7LIgshOpnEDSE6RsQJv6Ghgc8++4zPPvsMCFa4+eyzzygvL0fTNG699Vbuu+8+Xn31VTZs2MB1111HQUEBl19+OQAlJSVceOGFTJ06lXXr1vHBBx8wY8YMJk6cSEFBAQA/+tGPMJlMTJkyhY0bN/LXv/6V3//+98ycOTNmb1wI0XEkbggRByKt1v/ee+8p4Jhp8uTJSqlgE5s777xT5ebmKrPZrM4//3y1ZcuWsH3U1NSoa665RqWkpCibzaauv/56VV9fH7bO559/rsaOHavMZrPq0aOHevDBByMqpzSvkSmep+7WLE/ihkwyxWZqS+zQlFKqM0402pvT6cRut+OorZHnciLuOJ1O7BmZOBwO+X3GEYkbIt61JXZ0mVr6QgghhDg+SfhCCCFENyAJXwghhOgGJOELIYQQ3YChswvQXprrIkrf2CIeNf8uu2id2YQlcUPEu7bEji6b8GtqagAoLCru5JIIcXz19fXY7fbOLoY4TOKGSBTRxI4um/AzMjIAKC8vl4AaAafTSWFhIXv27JFmSRGI9HNTSlFfXx/qNEbEB4kb0ZG4EZ1oPre2xI4um/B1umD1BLvdLj/AKEi/4tGJ5HOThBJ/JG60jcSN6ET6uUUbO6TSnhBCCNENSMIXQgghuoEum/DNZjPz5s3DbDZ3dlESinxu0ZHPrWuQ7zE68rlFp6M/ty7bl74QQgghvtVlr/CFEEII8S1J+EIIIUQ3IAlfCCGE6AYk4QshhBDdgCR8IYQQohvokgl/0aJFFBUVYbFYGD16NOvWrevsInWqu+66C03TwqaBAweGlrtcLqZPn05mZiYpKSlMmDCBysrKsH2Ul5czfvx4kpKSyMnJ4fbbb8fn83X0W2lXq1at4pJLLqGgoABN03jllVfCliulmDt3Lvn5+VitVsrKyti6dWvYOrW1tUyaNAmbzUZaWhpTpkyhoaEhbJ0vvviCs88+G4vFQmFhIQsWLGjvtyZaSWLHtyRutE5CxQ3Vxbz44ovKZDKpP/3pT2rjxo1q6tSpKi0tTVVWVnZ20TrNvHnz1ODBg9WBAwdC0zfffBNa/vOf/1wVFhaqlStXqo8//liNGTNGnXnmmaHlPp9PDRkyRJWVlalPP/1UvfnmmyorK0vNnj27M95Ou3nzzTfVb37zG/XPf/5TAerll18OW/7ggw8qu92uXnnlFfX555+rSy+9VBUXF6umpqbQOhdeeKEaPny4WrNmjfrf//6n+vXrp6655prQcofDoXJzc9WkSZPUl19+qV544QVltVrVU0891VFvUxyHxI5wEjdaJ5HiRpdL+GeccYaaPn166G+/368KCgrU/PnzO7FUnWvevHlq+PDhLS6rq6tTRqNRvfTSS6F5mzdvVoBavXq1Uir4g9bpdKqioiK0zpNPPqlsNptyu93tWvbOcvSBGwgEVF5ennr44YdD8+rq6pTZbFYvvPCCUkqpTZs2KUB99NFHoXXeeustpWn/v727CUksiuIAfqaPJ0rUMyyfBUZBHwQFYSRCtUkSV9EqIiLatGjbolX7Vm2C2rqUdu0E0SIKExL7BqmwgugVfYgGgVZnFtGbeVNM0wyT5vv/QAjvVe49PP6H9F38xmdnZ8zMPDc3x0ajUVW3yclJbmxs/M87gvcgO9SQGx+X67mRVx/pp9NpikQi5HQ6lecKCgrI6XRSKBTK4sqy7+DggKqqqqiuro6Ghobo9PSUiIgikQhlMhlVzZqamshqtSo1C4VC1NLSQmazWZnjcrkomUzS3t7e524kS+LxOMmyrKpTWVkZ2e12VZ1EUaT29nZljtPppIKCAgqHw8qc7u5uEgRBmeNyuSgWi9Ht7e0n7QZ+hex4G3Lj3+RabuRVw7+6uqLHx0fVBUZEZDabSZblLK0q++x2O3k8HvL5fDQ/P0/xeJy6uroolUqRLMskCAKJoqh6zc81k2X5zZq+jGnByz5/d23JskyVlZWq8aKiIiovL0ctcxyy4zXkxr/LtdzI25/HhR/cbrfyd2trK9ntdqqpqaGFhQXS6/VZXBkA5CrkRv7Jq//wTSYTFRYWvrpT9OLigiRJytKqco8oitTQ0ECHh4ckSRKl02lKJBKqOT/XTJKkN2v6MqYFL/v83bUlSRJdXl6qxh8eHujm5ga1zHHIjvchNz4u13Ijrxq+IAhks9koEAgozz09PVEgECCHw5HFleWWu7s7Ojo6IovFQjabjYqLi1U1i8VidHp6qtTM4XDQzs6O6qL0+/1UWlpKzc3Nn77+bKitrSVJklR1SiaTFA6HVXVKJBIUiUSUOcFgkJ6enshutytzVlZWKJPJKHP8fj81NjaS0Wj8pN3Ar5Ad70NufFzO5cbf3ImYy7xeL+t0OvZ4PLy/v89jY2MsiqLqTlGtmZiY4OXlZY7H47y2tsZOp5NNJhNfXl4y8/PxGqvVysFgkDc2NtjhcLDD4VBe/3K8pre3lzc3N9nn83FFRUXeHa9JpVIcjUY5Go0yEfHMzAxHo1E+OTlh5ufjNaIo8uLiIm9vb3NfX9+bx2va2to4HA7z6uoq19fXq47XJBIJNpvNPDw8zLu7u+z1etlgMOBYXg5AdqghN/7MV8qNvGv4zMyzs7NstVpZEATu6Ojg9fX1bC8pqwYGBthisbAgCFxdXc0DAwN8eHiojN/f3/P4+DgbjUY2GAzc39/P5+fnqvc4Pj5mt9vNer2eTSYTT0xMcCaT+eyt/FdLS0tMRK8eIyMjzPx8xGZqaorNZjPrdDru6enhWCymeo/r62seHBzkkpISLi0t5dHRUU6lUqo5W1tb3NnZyTqdjqurq3l6evqztgjvQHb8gNz4M18pN74xM//FJxUAAADwheTVd/gAAADwNjR8AAAADUDDBwAA0AA0fAAAAA1AwwcAANAANHwAAAANQMMHAADQADR8AAAADUDDBwAA0AA0fAAAAA1AwwcAANCA7/TLn0Ws4qFUAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 640x480 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import cv2\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# 加载图像\n",
+    "img = cv2.imread('mug.png')\n",
+    "print(img.shape)\n",
+    "# 转换为灰度图像\n",
+    "gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n",
+    "\n",
+    "\n",
+    "harris = cv2.goodFeaturesToTrack(gray, 50, 0.01, 10,useHarrisDetector=1)\n",
+    "print(len(harris))\n",
+    "# 用红色标记检测到的角点，并保存\n",
+    "img_harris = np.copy(img)\n",
+    "for [[x, y]] in np.int0(harris):  # 注意这里的双重方括号\n",
+    "    cv2.circle(img_harris, (x, y), 5, [255, 0, 0], -1)\n",
+    "cv2.imwrite('harris.jpg', img_harris)\n",
+    "\n",
+    "# Shi-Thomas角点检测\n",
+    "shi = cv2.goodFeaturesToTrack(gray, 41, 0.01, 10,useHarrisDetector=0)\n",
+    "print(len(shi))\n",
+    "# 用红色标记检测到的角点，并保存\n",
+    "img_shi = np.copy(img)\n",
+    "for [[x, y]] in np.int0(shi):  # 注意这里的双重方括号\n",
+    "    cv2.circle(img_shi, (x, y), 5, [255, 0, 0], -1)\n",
+    "cv2.imwrite('shi.jpg', img_shi)\n",
+    "\n",
+    "# FAST角点检测\n",
+    "fast = cv2.FastFeatureDetector_create()\n",
+    "fast.setThreshold(50)\n",
+    "fast.setNonmaxSuppression(True)\n",
+    "keypoints = fast.detect(gray, None)\n",
+    "print(len(keypoints))\n",
+    "# 用红色标记检测到的角点，并保存\n",
+    "img_fast = np.copy(img)\n",
+    "for point in keypoints:\n",
+    "    x, y=point.pt\n",
+    "    x = int(x)\n",
+    "    y = int(y)\n",
+    "    cv2.circle(img_fast, (x, y), 5, [255, 0, 0], -1)\n",
+    "cv2.imwrite('fast.jpg', img_fast)\n",
+    "\n",
+    "# ORB角点检测\n",
+    "orb = cv2.ORB_create(nfeatures=50)\n",
+    "keypoints = orb.detect(gray, None)\n",
+    "print(len(keypoints))\n",
+    "# 用红色标记检测到的角点，并保存\n",
+    "img_orb = np.copy(img)\n",
+    "for point in keypoints:\n",
+    "    x, y=point.pt\n",
+    "    x = int(x)\n",
+    "    y = int(y)\n",
+    "    cv2.circle(img_orb, (x, y), 5, [255, 0, 0], -1)\n",
+    "cv2.imwrite('orb.jpg', img_orb)\n",
+    "\n",
+    "# 使用plt展示四张角点检测图\n",
+    "plt.subplot(221), plt.imshow(cv2.cvtColor(img_harris, cv2.COLOR_BGR2RGB)), plt.title('Harris')\n",
+    "plt.subplot(222), plt.imshow(cv2.cvtColor(img_shi, cv2.COLOR_BGR2RGB)), plt.title('Shi-Thomas')\n",
+    "plt.subplot(223), plt.imshow(cv2.cvtColor(img_fast, cv2.COLOR_BGR2RGB)), plt.title('FAST')\n",
+    "plt.subplot(224), plt.imshow(cv2.cvtColor(img_orb, cv2.COLOR_BGR2RGB)), plt.title('ORB')\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6f29151e-5727-4f46-8d6d-8fa88fa509d1",
+   "metadata": {},
+   "outputs": [],
+   "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.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

jupyter/去除孤立线.ipynb

@@ -0,0 +1,33 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8d8b6b0a-8cb6-46aa-aaa5-8bb266a56f76",
+   "metadata": {},
+   "outputs": [],
+   "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.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

jupyter/模型质量检测.ipynb

@@ -0,0 +1,402 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "97103d1f-2f48-4613-b438-862dbcb50312",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import trimesh\n",
+    "from scipy.spatial.distance import directed_hausdorff\n",
+    "from skimage import measure\n",
+    "import os\n",
+    "\n",
+    "def check_model_similarity(model1, model2, savedir):\n",
+    "    # 加载模型\n",
+    "    mesh1 = trimesh.load_mesh(model1)\n",
+    "    mesh2 = trimesh.load_mesh(model2)\n",
+    "\n",
+    "    # 计算两个模型之间的欧氏距离\n",
+    "    distance = np.linalg.norm(mesh1.centroid - mesh2.centroid)\n",
+    "\n",
+    "    # 计算重建模型中未被覆盖的原始模型的比例\n",
+    "    uncovered_ratio = 1 - mesh2.area / mesh1.area\n",
+    "\n",
+    "    # 计算重建模型的法向量和原始模型的法向量的差值的绝对值\n",
+    "    normals_difference = np.abs(mesh1.face_normals.mean(axis=0) - mesh2.face_normals.mean(axis=0)).sum()\n",
+    "\n",
+    "    # 计算Hausdorff Distance\n",
+    "    hausdorff_distance = max(directed_hausdorff(mesh1.vertices, mesh2.vertices)[0],\n",
+    "                             directed_hausdorff(mesh2.vertices, mesh1.vertices)[0])\n",
+    "\n",
+    "    # 计算3D Histogram Comparison（这里只是一个简化的例子，具体的比较方法可能需要根据你的需求进行调整）\n",
+    "    hist1, _ = np.histogramdd(mesh1.vertices, bins=(30, 30, 30))\n",
+    "    hist2, _ = np.histogramdd(mesh2.vertices, bins=(30, 30, 30))\n",
+    "    hist_difference = np.abs(hist1 - hist2).sum()\n",
+    "\n",
+    "\n",
+    "    # 创建一个DataFrame来存储结果\n",
+    "    df = pd.DataFrame({\n",
+    "        'Model1': [model1],\n",
+    "        'Model2': [model2],\n",
+    "        'Euclidean Distance': [distance],\n",
+    "        'Uncovered Ratio': [uncovered_ratio],\n",
+    "        'Normals Difference': [normals_difference],\n",
+    "        'Hausdorff Distance': [hausdorff_distance],\n",
+    "        'Histogram Difference': [hist_difference],\n",
+    "    })\n",
+    "\n",
+    "    # 将结果保存到Excel文件\n",
+    "    df.to_excel(savedir + 'model_comparison.xlsx', index=False)\n",
+    "def check_dir_models_similarity(target_model, model_dir, savedir):\n",
+    "    # 加载目标模型\n",
+    "    mesh_target = trimesh.load_mesh(target_model)\n",
+    "    \n",
+    "    # 获取文件夹中所有的模型文件\n",
+    "    models = [f for f in os.listdir(model_dir) if f.endswith('.stl') or f.endswith('.ply')]  # 根据你的模型文件类型来修改\n",
+    "\n",
+    "    result_list = []\n",
+    "    for model in models:\n",
+    "        # 加载模型\n",
+    "        mesh = trimesh.load_mesh(os.path.join(model_dir, model))\n",
+    "\n",
+    "        # 计算两个模型之间的欧氏距离\n",
+    "        distance = np.linalg.norm(mesh_target.centroid - mesh.centroid)\n",
+    "\n",
+    "        # 计算重建模型中未被覆盖的原始模型的比例\n",
+    "        uncovered_ratio = 1 - mesh.area / mesh_target.area\n",
+    "\n",
+    "        # 计算重建模型的法向量和原始模型的法向量的差值的绝对值\n",
+    "        normals_difference = np.abs(mesh_target.face_normals.mean(axis=0) - mesh.face_normals.mean(axis=0)).sum()\n",
+    "\n",
+    "        # 计算Hausdorff Distance\n",
+    "        hausdorff_distance = max(directed_hausdorff(mesh_target.vertices, mesh.vertices)[0],\n",
+    "                                 directed_hausdorff(mesh.vertices, mesh_target.vertices)[0])\n",
+    "\n",
+    "        # 计算3D Histogram Comparison\n",
+    "        hist_target, _ = np.histogramdd(mesh_target.vertices, bins=(30, 30, 30))\n",
+    "        hist, _ = np.histogramdd(mesh.vertices, bins=(30, 30, 30))\n",
+    "        hist_difference = np.abs(hist_target - hist).sum()\n",
+    "\n",
+    "        result_list.append({\n",
+    "            'Model': model,\n",
+    "            'Euclidean Distance': distance,\n",
+    "            'Uncovered Ratio': uncovered_ratio,\n",
+    "            'Normals Difference': normals_difference,\n",
+    "            'Hausdorff Distance': hausdorff_distance,\n",
+    "            'Histogram Difference': hist_difference,\n",
+    "        })\n",
+    "        \n",
+    "    # 创建一个DataFrame来存储结果\n",
+    "    df = pd.DataFrame(result_list)\n",
+    "\n",
+    "    # 将结果保存到Excel文件\n",
+    "    df.to_excel(savedir + 'model_comparison.xlsx', index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "98d18315-3d93-44e7-9c0c-4e94131fc568",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#运行检查模型相似度的函数，target_model是基准模型的地址，model_dir是和基准模型对比的模型的地址，savedir是保存检测结果的地址\n",
+    "check_dir_models_similarity('928\\\\modelcompare\\\\e0\\\\0.ply', '928\\\\modelcompare\\\\e\\\\', '928\\\\modelcompare\\\\e\\\\')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "d6c299f1-f88a-4582-b340-748e0b10b983",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import pandas as pd\n",
+    "from open3d import io as o3d_io\n",
+    "import numpy as np\n",
+    "\n",
+    "def check_model_quality(modelsdir, savedir):\n",
+    "    if not os.path.exists(savedir):\n",
+    "        os.makedirs(savedir)\n",
+    "    # 创建一个空的DataFrame来存储结果\n",
+    "    result_df = pd.DataFrame(columns=['文件名', '法向量平均值', '法向量差异', '孤立顶点数量', '无效边数量', '相交面数量', '顶点数量'])\n",
+    "\n",
+    "    # 遍历modelsdir中的所有文件\n",
+    "    for filename in os.listdir(modelsdir):\n",
+    "        # 只处理ply文件\n",
+    "        if filename.endswith(\".ply\"):\n",
+    "            # 读取模型\n",
+    "            model = o3d_io.read_triangle_mesh(os.path.join(modelsdir, filename))\n",
+    "            \n",
+    "            # 计算法向量平均值和差异\n",
+    "            avg_normal = np.mean(model.vertex_normals, axis=0)\n",
+    "            diff_normal = np.std(model.vertex_normals - avg_normal)\n",
+    "\n",
+    "            # 计算孤立顶点数量、无效边数量、相交面数量\n",
+    "            # 这里需要您根据实际情况编写相应的函数\n",
+    "            isolated_vertices = 0\n",
+    "            invalid_edges = 0\n",
+    "            intersecting_faces = 0\n",
+    "\n",
+    "            # 计算顶点数量\n",
+    "            vertices_array = np.asarray(model.vertices)\n",
+    "            vertices_in_cube = np.sum(\n",
+    "                (vertices_array >= 0) & (vertices_array <= 0.1),\n",
+    "                axis=0  # 在每个坐标上分别计算\n",
+    "            ).min()  # 选择最小的数量，因为我们需要在所有坐标上都满足条件\n",
+    "\n",
+    "            # 将结果添加到DataFrame中\n",
+    "            result_df = pd.concat([result_df, pd.DataFrame({\n",
+    "                '文件名': [filename],\n",
+    "                '法向量平均值': [avg_normal],\n",
+    "                '法向量差异': [diff_normal],\n",
+    "                '孤立顶点数量': [isolated_vertices],\n",
+    "                '无效边数量': [invalid_edges],\n",
+    "                '相交面数量': [intersecting_faces],\n",
+    "                '顶点数量': [vertices_in_cube]\n",
+    "            })], ignore_index=True)\n",
+    "\n",
+    "    # 将结果保存到csv文件中\n",
+    "    result_df.to_csv(os.path.join(savedir, 'quality_report.csv'), index=False,encoding='gbk')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "030dd624-b910-4040-890f-b6c3471617fb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "check_model_similarity('928\\\\modelcompare\\\\b\\\\b0.ply', '928\\\\modelcompare\\\\b\\\\b2.ply', '928\\\\modelcompare\\\\b\\\\')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "03339287-7351-4f32-84e3-665a2a4d220c",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "ImportError",
+     "evalue": "cannot import name 'shape_context' from 'skimage.measure' (D:\\SubDiffusion\\venv\\lib\\site-packages\\skimage\\measure\\__init__.py)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mImportError\u001b[0m                               Traceback (most recent call last)",
+      "Cell \u001b[1;32mIn[11], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mskimage\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mmeasure\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m shape_context\n\u001b[0;32m      2\u001b[0m sc \u001b[38;5;241m=\u001b[39m shape_context\u001b[38;5;241m.\u001b[39mShapeContext()\n",
+      "\u001b[1;31mImportError\u001b[0m: cannot import name 'shape_context' from 'skimage.measure' (D:\\SubDiffusion\\venv\\lib\\site-packages\\skimage\\measure\\__init__.py)"
+     ]
+    }
+   ],
+   "source": [
+    "from skimage.measure import shape_context\n",
+    "sc = shape_context.ShapeContext()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "ab723713-9244-46ac-807b-e9cd064e4197",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "D:\\SubDiffusion\\venv\\lib\\site-packages\\numpy\\core\\fromnumeric.py:3504: RuntimeWarning: Mean of empty slice.\n",
+      "  return _methods._mean(a, axis=axis, dtype=dtype,\n",
+      "D:\\SubDiffusion\\venv\\lib\\site-packages\\numpy\\core\\_methods.py:121: RuntimeWarning: invalid value encountered in divide\n",
+      "  ret = um.true_divide(\n",
+      "D:\\SubDiffusion\\venv\\lib\\site-packages\\numpy\\core\\_methods.py:206: RuntimeWarning: Degrees of freedom <= 0 for slice\n",
+      "  ret = _var(a, axis=axis, dtype=dtype, out=out, ddof=ddof,\n",
+      "D:\\SubDiffusion\\venv\\lib\\site-packages\\numpy\\core\\_methods.py:163: RuntimeWarning: invalid value encountered in divide\n",
+      "  arrmean = um.true_divide(arrmean, div, out=arrmean,\n",
+      "D:\\SubDiffusion\\venv\\lib\\site-packages\\numpy\\core\\_methods.py:198: RuntimeWarning: invalid value encountered in scalar divide\n",
+      "  ret = ret.dtype.type(ret / rcount)\n",
+      "C:\\Users\\胡逸飞\\AppData\\Local\\Temp\\ipykernel_9228\\3375845982.py:37: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
+      "  result_df = pd.concat([result_df, pd.DataFrame({\n"
+     ]
+    }
+   ],
+   "source": [
+    "check_model_quality('D:\\\\SubDiffusion\\\\928\\\\lunwen\\\\b\\\\mdoel', 'D:\\\\SubDiffusion\\\\928\\\\lunwen\\\\b\\\\excel')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "b2117192-647a-457e-998c-d9168a94259e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = o3d_io.read_triangle_mesh('D:\\\\SubDiffusion\\\\928\\\\lunwen\\\\b\\\\mdoel\\\\drill_0_1.ply')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "2d4516e7-372b-4373-a4a6-22ebc12cddcf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "avg_normal = np.mean(model.vertex_normals, axis=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "7ea93115-7759-4b21-8abb-c3c1c9f58462",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([ 0.00606041, -0.02948447, -0.01463793])"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "avg_normal"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "f3c405fe-c413-4e6d-8f33-c10a07914717",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "diff_normal = np.std(model.vertex_normals - avg_normal)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "1e1335e5-ec3b-47ef-b8c1-db4179b1369e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.5770267666909921"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "diff_normal"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "0542de38-511a-4c4c-b697-5165070f9150",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "vertices_array = np.asarray(model.vertices)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "34bc713d-077d-4181-b55d-1a24ded2b0da",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[-0.9866792 ,  0.98449612, -0.75193799],\n",
+       "       [-0.98875535,  0.98449612, -0.7364341 ],\n",
+       "       [-0.98973423,  0.98449612, -0.72093022],\n",
+       "       ...,\n",
+       "       [ 0.96899223,  0.98449612, -0.45131803],\n",
+       "       [ 0.98449612,  0.98449612, -0.99188083],\n",
+       "       [ 0.98449612,  0.98449612, -0.45086342]])"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "vertices_array"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "a7a1a534-c499-4cf9-8036-bcfd98d5f75d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "vertices_in_cube = np.sum((vertices_array >= 0) & (vertices_array <= 0.1))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "e2726a87-df35-45a9-9589-f8c8d79c976a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "vertices_in_cube"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "abf0fcb1-bb1d-452d-ac9a-1bc5f3510e5b",
+   "metadata": {},
+   "outputs": [],
+   "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.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

jupyter/测试.ipynb

@@ -0,0 +1,430 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "861a772d-2016-48c2-98ac-6090e6aea2f1",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "50268a22373a43c6a9f77b11bfffacab",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "interactive(children=(FloatSlider(value=1.0, description='参数：', max=10.0), Output()), _dom_classes=('widget-in…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<function update_parameter at 0x00000283DB1CF880>\n"
+     ]
+    }
+   ],
+   "source": [
+    "import ipywidgets as widgets\n",
+    "from IPython.display import display\n",
+    "def update_parameter(parameter_value):\n",
+    "    # 在这里执行代码，并使用 parameter_value 作为参数值\n",
+    "    # 例如，你可以将 parameter_value 用于某个函数或条件\n",
+    "    print(\"参数值已更新为:\", parameter_value)\n",
+    "\n",
+    "# 创建一个滑动条控件\n",
+    "parameter_slider = widgets.FloatSlider(\n",
+    "    value=1.0,  # 初始值\n",
+    "    min=0.0,    # 最小值\n",
+    "    max=10.0,   # 最大值\n",
+    "    step=0.1,   # 步进值\n",
+    "    description='参数：'\n",
+    ")\n",
+    "\n",
+    "# 使用 interactive 函数将滑动条控件与函数关联起来\n",
+    "interactive_plot = widgets.interactive(update_parameter, parameter_value=parameter_slider)\n",
+    "\n",
+    "# 显示滑动条\n",
+    "display(interactive_plot)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "cb54e39e-0113-4acb-9eba-23fdfa22178e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "630d6888ed9b4999900fcd95722a3652",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "FloatSlider(value=0.0, description='参数paramter1：')"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "f173ad0d928c4f788e8cbafd02644a02",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "FloatSlider(value=0.0, description='参数paramter2：')"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import ipywidgets as widgets\n",
+    "from IPython.display import display\n",
+    "# 定义paramter1和paramter2的初始值\n",
+    "initial_paramter1_value = 0.0\n",
+    "initial_paramter2_value = 0.0\n",
+    "\n",
+    "# 创建滑动条控件用于paramter1\n",
+    "paramter1_slider = widgets.FloatSlider(\n",
+    "    value=initial_paramter1_value,\n",
+    "    min=0.0,\n",
+    "    max=100.0,\n",
+    "    step=0.1,\n",
+    "    description='参数paramter1：'\n",
+    ")\n",
+    "\n",
+    "# 创建滑动条控件用于paramter2\n",
+    "paramter2_slider = widgets.FloatSlider(\n",
+    "    value=initial_paramter2_value,\n",
+    "    min=0.0,\n",
+    "    max=100.0,\n",
+    "    step=0.1,\n",
+    "    description='参数paramter2：'\n",
+    ")\n",
+    "def update_paramters(change):\n",
+    "    paramter1_value = paramter1_slider.value\n",
+    "    paramter2_value = paramter2_slider.value\n",
+    "    sum_paramters = paramter1_value + paramter2_value\n",
+    "    # 输出paramter1和paramter2的和\n",
+    "    print(f\"参数paramter1的值：{paramter1_value}\")\n",
+    "    print(f\"参数paramter2的值：{paramter2_value}\")\n",
+    "    print(f\"paramter1 + paramter2 = {sum_paramters}\")\n",
+    "\n",
+    "# 将滑动条控件的值与函数绑定\n",
+    "paramter1_slider.observe(update_paramters, names='value')\n",
+    "paramter2_slider.observe(update_paramters, names='value')\n",
+    "display(paramter1_slider)\n",
+    "display(paramter2_slider)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "d3d88790-abe2-4c4c-a3f6-fdb1acd83c47",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'paramter1_value' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[1;32mIn[5], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mparamter1_value\u001b[49m\n",
+      "\u001b[1;31mNameError\u001b[0m: name 'paramter1_value' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "paramter1_value\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "f7281bdb-b7b6-4be1-9ef7-6e5553f340ee",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "948a80daf63e4c809b3e5d02030d2cd6",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "interactive(children=(FloatSlider(value=5.0, description='paramter1', max=10.0), FloatSlider(value=5.0, descri…"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from ipywidgets import interact, interactive, fixed, interact_manual\n",
+    "import ipywidgets as widgets\n",
+    "\n",
+    "def f(paramter1, paramter2):\n",
+    "    print(f'paramter1: {paramter1}, paramter2: {paramter2}, sum: {paramter1 + paramter2}')\n",
+    "    return paramter1, paramter2\n",
+    "\n",
+    "interactive_plot = interactive(f, paramter1=(0.0,10.0), paramter2=(0.0,10.0))\n",
+    "interactive_plot\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "98697097-952d-4a2d-873a-dfbb9f2b5f83",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "paramter1: 6.6, paramter2: 5.9\n"
+     ]
+    }
+   ],
+   "source": [
+    "paramter1, paramter2 = interactive_plot.result\n",
+    "print(f'paramter1: {paramter1}, paramter2: {paramter2}')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "407a07f0-af7f-49ce-9518-42dc455d466b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "两个圆相交\n"
+     ]
+    }
+   ],
+   "source": [
+    "import math\n",
+    "\n",
+    "def calculate_distance(p1, p2):\n",
+    "    return math.sqrt((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2)\n",
+    "\n",
+    "def check_circles(line1, line2):\n",
+    "    # 计算线段的中点作为圆心\n",
+    "    c1 = [(line1[0][0]+line1[1][0])/2, (line1[0][1]+line1[1][1])/2]\n",
+    "    c2 = [(line2[0][0]+line2[1][0])/2, (line2[0][1]+line2[1][1])/2]\n",
+    "\n",
+    "    # 计算线段的长度作为圆的直径，因此半径是长度的一半\n",
+    "    r1 = calculate_distance(line1[0], line1[1]) / 2\n",
+    "    r2 = calculate_distance(line2[0], line2[1]) / 2\n",
+    "\n",
+    "    # 计算两个圆心之间的距离\n",
+    "    d = calculate_distance(c1, c2)\n",
+    "\n",
+    "    # 判断两个圆的关系\n",
+    "    if d > r1 + r2:\n",
+    "        return \"两个圆没有交点\"\n",
+    "    elif d == r1 + r2:\n",
+    "        return \"两个圆相切\"\n",
+    "    elif d < r1 + r2:\n",
+    "        if d > abs(r1 - r2):\n",
+    "            return \"两个圆相交\"\n",
+    "        elif d == abs(r1 - r2):\n",
+    "            return \"一个圆在另一个圆内相切\"\n",
+    "        else:\n",
+    "            return \"一个圆在另一个圆内且不相交\"\n",
+    "    else:\n",
+    "        return \"未知情况\"\n",
+    "\n",
+    "# 测试\n",
+    "line1 = [(0, 0), (2, 0)]\n",
+    "line2 = [(1, 0), (3, 0)]\n",
+    "print(check_circles(line1, line2))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "6064e6a6-e673-49f1-84eb-2c09d36333b1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "True\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import math\n",
+    "\n",
+    "# 计算两点之间的距离\n",
+    "def calculate_distance(p1, p2):\n",
+    "    return np.sqrt((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2)\n",
+    "\n",
+    "# 计算两线段的角度\n",
+    "def calculate_angle(p1, p2):\n",
+    "    return math.degrees(math.atan2(p2[1] - p1[1], p2[0] - p1[0]))\n",
+    "\n",
+    "# 计算点到线段的最短距离\n",
+    "def point_to_line_distance(point, line):\n",
+    "    p1, p2 = line\n",
+    "    line_vector = np.array(p2) - np.array(p1)\n",
+    "    point_vector = np.array(point) - np.array(p1)\n",
+    "    line_length = np.linalg.norm(line_vector)\n",
+    "    unit_line_vector = line_vector / line_length\n",
+    "    projected_point_length = np.dot(point_vector, unit_line_vector)\n",
+    "    if projected_point_length < 0:\n",
+    "        return calculate_distance(point, p1)\n",
+    "    elif projected_point_length > line_length:\n",
+    "        return calculate_distance(point, p2)\n",
+    "    else:\n",
+    "        projected_point = p1 + projected_point_length * unit_line_vector\n",
+    "        return calculate_distance(point, projected_point)\n",
+    "\n",
+    "# 判断两线段的一致性\n",
+    "def check_consistency(line1, line2):\n",
+    "    # 判断角度差\n",
+    "    angle1 = calculate_angle(*line1)\n",
+    "    angle2 = calculate_angle(*line2)\n",
+    "    if abs(angle1 - angle2) > 2:\n",
+    "        return False\n",
+    "\n",
+    "    # 判断线段1上所有点到线段2的垂直距离\n",
+    "    for point in line1:\n",
+    "        if point_to_line_distance(point, line2) > 5:\n",
+    "            return False\n",
+    "\n",
+    "    # 判断以线段为直径的圆的关系\n",
+    "    c1 = [(line1[0][0]+line1[1][0])/2, (line1[0][1]+line1[1][1])/2]\n",
+    "    c2 = [(line2[0][0]+line2[1][0])/2, (line2[0][1]+line2[1][1])/2]\n",
+    "    r1 = calculate_distance(line1[0], line1[1]) / 2\n",
+    "    r2 = calculate_distance(line2[0], line2[1]) / 2\n",
+    "    d = calculate_distance(c1, c2)\n",
+    "    if d > r1 + r2:\n",
+    "        return False\n",
+    "\n",
+    "    return True\n",
+    "\n",
+    "# 测试\n",
+    "line1 = [(0, 0), (2, 0)]\n",
+    "line2 = [(1, 0), (3, 0)]\n",
+    "print(check_consistency(line1, line2)) # 输出：True\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "cb6fd875-453c-4085-a800-e791de9c0330",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[(0, 0), (2, 0)], [(0, 0), (0, 2)]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "def find_matching_lines(lines1, lines2):\n",
+    "    lines3 = []\n",
+    "    for line1 in lines1:\n",
+    "        for line2 in lines2:\n",
+    "            if check_consistency(line1, line2):\n",
+    "                lines3.append(line1)\n",
+    "                break\n",
+    "    return lines3\n",
+    "\n",
+    "# 测试\n",
+    "lines1 = [[(0, 0), (2, 0)], [(0, 0), (0, 2)], [(0, 0), (-2, 0)]]\n",
+    "lines2 = [[(1, 0), (3, 0)], [(1, 1), (3, 1)], [(0, 0), (0, 2)]]\n",
+    "lines3 = find_matching_lines(lines1, lines2)\n",
+    "print(lines3)  # 输出：[[(0, 0), (2, 0)], [(0, 0), (0, 2)]]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "7cdccf36-10c7-4b2a-8830-9c7ab3840ec5",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from scipy.spatial import ConvexHull\n",
+    "\n",
+    "# 生成100个随机点\n",
+    "points = np.random.rand(100, 2)\n",
+    "\n",
+    "# 计算凸包\n",
+    "hull = ConvexHull(points)\n",
+    "\n",
+    "# 绘制所有点\n",
+    "plt.scatter(points[:,0], points[:,1])\n",
+    "\n",
+    "# 绘制凸包的边\n",
+    "for simplex in hull.simplices:\n",
+    "    plt.plot(points[simplex, 0], points[simplex, 1], 'k-')\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f8732912-7fc5-44fc-b89a-d1d24f8337dc",
+   "metadata": {},
+   "outputs": [],
+   "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.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

jupyter/深度图精确度比较.ipynb

@@ -0,0 +1,68 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "b4ce7b4b-3994-45ba-812e-a2bf53544df2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cv2\n",
+    "import numpy as np\n",
+    "import os\n",
+    "from sklearn.metrics import mean_squared_error\n",
+    "import pandas as pd\n",
+    "\n",
+    "def compare_depth_maps(dir1, dir2):\n",
+    "    # 读取dir2中的图像并调整尺寸\n",
+    "    img2 = cv2.imread(dir2, cv2.IMREAD_GRAYSCALE)\n",
+    "    img2_resized = cv2.resize(img2, (512, 512))\n",
+    "\n",
+    "    mse_list = []\n",
+    "    for file in os.listdir(dir1):\n",
+    "        if file.endswith(\".png\"):   # 假设所有深度图都是.png格式\n",
+    "            # 读取dir1中的图像\n",
+    "            img1 = cv2.imread(os.path.join(dir1, file), cv2.IMREAD_GRAYSCALE)\n",
+    "            # 计算MSE并添加到列表中\n",
+    "            mse = mean_squared_error(img1, img2_resized)\n",
+    "            mse_list.append([file, mse])\n",
+    "\n",
+    "    # 将结果写入Excel\n",
+    "    df = pd.DataFrame(mse_list, columns=['Image', 'MSE'])\n",
+    "    df.to_excel(os.path.join(dir1, 'mse_results.xlsx'), index=False)\n",
+    "\n",
+    "# 使用函数\n",
+    "compare_depth_maps('D:\\\\SubDiffusion\\\\928\\\\lunwen\\\\f\\\\f-dp\\\\fake', 'D:\\\\SubDiffusion\\\\928\\\\lunwen\\\\f\\\\f-dp\\\\real\\\\f-4.png')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cfef9116-928c-4aab-9b89-6ed2979170b8",
+   "metadata": {},
+   "outputs": [],
+   "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.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

jupyter/深度检测midas.ipynb

@@ -0,0 +1,160 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "85d74fc2-25df-4abb-986a-b0ec3c8949b6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torchvision.transforms as transforms\n",
+    "import matplotlib.pyplot as plt\n",
+    "from PIL import Image\n",
+    "import numpy as np\n",
+    "import matplotlib.cm as cm\n",
+    "import os\n",
+    "# 加载Midas深度检测模型\n",
+    "model = torch.hub.load('intel-isl/MiDaS', 'MiDaS')\n",
+    "# 设置模型为评估模式\n",
+    "model.eval()\n",
+    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+    "print(torch.cuda.is_available())\n",
+    "model = model.to(device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "2432caaa-8d6d-4158-b009-9d6ad4b79c90",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def img_depth(imgdir, n1, n2=True):\n",
+    "    # 加载图像\n",
+    "    image = Image.open(imgdir)\n",
+    "\n",
+    "    # 调整图像大小，使最长边等于n1\n",
+    "    max_size = n1\n",
+    "    if image.size[0] > image.size[1]:\n",
+    "        wpercent = max_size / float(image.size[0])\n",
+    "        hsize = int((float(image.size[1]) * float(wpercent)))\n",
+    "        image = image.resize((max_size, hsize), Image.Resampling.BILINEAR)\n",
+    "    else:\n",
+    "        hpercent = max_size / float(image.size[1])\n",
+    "        wsize = int((float(image.size[0]) * float(hpercent)))\n",
+    "        image = image.resize((wsize, max_size), Image.Resampling.BILINEAR)\n",
+    "\n",
+    "    # 创建一个n1*n1的纯黑色图像\n",
+    "    background = Image.new('RGB', (n1, n1), (0, 0, 0))\n",
+    "\n",
+    "    # 计算输入图像在背景图像中的位置\n",
+    "    bg_w, bg_h = background.size\n",
+    "    img_w, img_h = image.size\n",
+    "    offset = ((bg_w - img_w) // 2, (bg_h - img_h) // 2)\n",
+    "\n",
+    "    # 将输入图像放在背景图像中\n",
+    "    background.paste(image, offset)\n",
+    "\n",
+    "    # 将图像转换为张量\n",
+    "    input_image = transforms.ToTensor()(background).unsqueeze(0).to(device)\n",
+    "\n",
+    "    # 生成深度图\n",
+    "    with torch.no_grad():\n",
+    "        prediction = model(input_image)\n",
+    "\n",
+    "    # 将深度图转换为numpy数组，并归一化到0-255\n",
+    "    depth_array = prediction.squeeze().cpu().numpy()\n",
+    "    if n2:\n",
+    "        depth_array = ((depth_array - depth_array.min()) * (255 / (depth_array.max() - depth_array.min()))).astype(np.uint8)\n",
+    "        depth_array = cm.gray(depth_array)\n",
+    "\n",
+    "    return depth_array\n",
+    "\n",
+    "def dir_depth(dir1, dir2, n1, n2=True):\n",
+    "    # 检查输出目录是否存在，如果不存在则创建\n",
+    "    if not os.path.exists(dir2):\n",
+    "        os.makedirs(dir2)\n",
+    "\n",
+    "    # 处理输入目录中的所有图像\n",
+    "    count = 0\n",
+    "    for filename in os.listdir(dir1):\n",
+    "        if filename.endswith('.png') or filename.endswith('.jpg'):\n",
+    "            # 生成深度图\n",
+    "            depth_array = img_depth(os.path.join(dir1, filename), n1, n2)\n",
+    "\n",
+    "            # 保存深度图为png文件\n",
+    "            plt.imsave(os.path.join(dir2, os.path.splitext(filename)[0] + '_depth.png'), depth_array)\n",
+    "\n",
+    "            count += 1\n",
+    "\n",
+    "    return f'已经转化{count}张图像'\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "2d869e3d-bbcf-497d-9044-7178df0fe4ef",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: total: 16 s\n",
+      "Wall time: 20.1 s\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'已经转化72张图像'"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "dir_depth('928\\\\hairdryer\\\\928-2', '928\\\\hairdryer\\\\928-2-dp', 960, True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "29482ccb-e1b2-4cb4-9806-52feaf954121",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# 可视化深度图\n",
+    "plt.imshow(prediction.squeeze().cpu(), cmap='viridis')\n",
+    "plt.axis('off')\n",
+    "plt.show()\n"
+   ]
+  }
+ ],
+ "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.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

jupyter/生成模型旋转动画.ipynb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:350977359a7730647cf5a64957af9c25259e334e18dc5144147c41e1ca4fc4e1
+size 16071606

jupyter/直线检测.ipynb

@@ -0,0 +1,99 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "b9318bf6-d900-407e-926f-490041e4a34b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 1000x1000 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import cv2\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "img = cv2.imread('928\\\\linetest\\\\4.jpg')\n",
+    "gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n",
+    "edges = cv2.Canny(gray,150,255,apertureSize = 3)\n",
+    "lines = cv2.HoughLinesP(edges, rho=1, theta=np.pi/180, threshold=20, minLineLength=10, maxLineGap=10)\n",
+    "blank_image=np.zeros_like(img)\n",
+    "for line in lines.reshape(-1,4):\n",
+    "    x1, y1, x2, y2 = line\n",
+    "    cv2.line(blank_image, (x1, y1), (x2, y2), (0, 255, 0), 1)\n",
+    "plt.subplot(131),plt.imshow(blank_image),plt.title('Hough')\n",
+    "cv2.imwrite('928\\\\linetest\\\\hough4.png',blank_image,[cv2.IMWRITE_PNG_COMPRESSION, 0])\n",
+    "lsd = cv2.createLineSegmentDetector(0)\n",
+    "lines = lsd.detect(edges)[0]\n",
+    "blank_image=np.zeros_like(img)\n",
+    "for dline in lines:\n",
+    "    x0 = int(round(dline[0][0]))\n",
+    "    y0 = int(round(dline[0][1]))\n",
+    "    x1 = int(round(dline[0][2]))\n",
+    "    y1 = int(round(dline[0][3]))\n",
+    "    cv2.line(blank_image, (x0, y0), (x1,y1), (0, 255, 0), 1)\n",
+    "plt.subplot(132),plt.imshow(blank_image),plt.title('LSD')\n",
+    "cv2.imwrite('928\\\\linetest\\\\lsd4.png',blank_image,[cv2.IMWRITE_PNG_COMPRESSION, 0])\n",
+    "fld = cv2.ximgproc.createFastLineDetector()\n",
+    "lines = fld.detect(edges)\n",
+    "blank_image=np.zeros_like(img)\n",
+    "for dline in lines:\n",
+    "    x0 = int(round(dline[0][0]))\n",
+    "    y0 = int(round(dline[0][1]))\n",
+    "    x1 = int(round(dline[0][2]))\n",
+    "    y1 = int(round(dline[0][3]))\n",
+    "    cv2.line(blank_image, (x0, y0), (x1,y1), (0,255,0), 1)\n",
+    "plt.subplot(133),plt.imshow(blank_image),plt.title('FLD')\n",
+    "cv2.imwrite('928\\\\linetest\\\\fld4.png',blank_image,[cv2.IMWRITE_PNG_COMPRESSION, 0])\n",
+    "plt.figure(figsize=(10,10))\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cb582625-b80e-4205-9fc3-a846ea1d8000",
+   "metadata": {},
+   "outputs": [],
+   "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.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

jupyter/线稿检测.ipynb

@@ -0,0 +1,33 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7367a71d-25b2-4d12-af29-99c0f00ec932",
+   "metadata": {},
+   "outputs": [],
+   "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.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

jupyter/连通性测试.ipynb

@@ -0,0 +1,95 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "e50548bd-15f8-46ea-98a1-2222bc05ab7c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import cv2\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "def find_connected_components(img, x1, y1):\n",
+    "    # Convert the image to grayscale\n",
+    "    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n",
+    "\n",
+    "    # Find connected components\n",
+    "    ret, labels = cv2.connectedComponents(gray)\n",
+    "\n",
+    "    # Get the label of the point (x1, y1)\n",
+    "    label = labels[y1, x1]\n",
+    "\n",
+    "    # Get all points in the same connected component as (x1, y1)\n",
+    "    area_points = np.where(labels == label)\n",
+    "\n",
+    "    return area_points\n",
+    "\n",
+    "def plot_connected_area(img, area_points):\n",
+    "    # Create a blank image\n",
+    "    img_copy = np.zeros(img.shape, dtype=np.uint8)\n",
+    "\n",
+    "    # Color the connected area\n",
+    "    img_copy[area_points] = [255, 0, 0]  # Red color\n",
+    "\n",
+    "    # Convert color space for matplotlib\n",
+    "    img_copy = cv2.cvtColor(img_copy, cv2.COLOR_BGR2RGB)\n",
+    "\n",
+    "    # Plot the image\n",
+    "    plt.imshow(img_copy)\n",
+    "    plt.show()\n",
+    "\n",
+    "# Load an image\n",
+    "img = cv2.imread('c-4.png')\n",
+    "\n",
+    "# Find connected points\n",
+    "x1, y1 = 100, 100  # example coordinates\n",
+    "area_points = find_connected_components(img, x1, y1)\n",
+    "\n",
+    "# Plot the connected area\n",
+    "plot_connected_area(img, area_points)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "da26c857-566b-4357-a992-88799d146f7a",
+   "metadata": {},
+   "outputs": [],
+   "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.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}