{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load remove_background.py\n",
    "import numpy as np\n",
    "from skimage import io, filters, morphology, measure, color\n",
    "from skimage.util import img_as_float\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "\n",
    "def remove_background(image: np.ndarray, \n",
    "                      sigma: float = 1, \n",
    "                      min_size: int = 50, \n",
    "                      area_threshold: int = 50, \n",
    "                      min_size_bkg=1000, \n",
    "                      display=False) -> np.ndarray:\n",
    "    \"\"\"\n",
    "    Remove the background from an image of spheres.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    image : np.ndarray\n",
    "        The input image.\n",
    "    sigma : float\n",
    "        Standard deviation for Gaussian filter.\n",
    "    min_size : int\n",
    "        Minimum size of objects to keep.\n",
    "    area_threshold : int\n",
    "        Minimum area of holes to fill.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    np.ndarray\n",
    "        The cleaned image.\n",
    "    \"\"\"\n",
    "\n",
    "    # Load the image\n",
    "    \n",
    "    image_float = img_as_float(image)\n",
    "\n",
    "    # Apply Gaussian filter to reduce noise\n",
    "    image_smooth = filters.gaussian(image_float, sigma=sigma)\n",
    "\n",
    "    # plt.imshow(image_smooth)\n",
    "\n",
    "    # Use Otsu's method to find a threshold for segmentation\n",
    "    thresh = filters.threshold_otsu(image_smooth)\n",
    "\n",
    "    # Create a binary mask\n",
    "    binary_mask = image_smooth > thresh\n",
    "\n",
    "    # plt.imshow(binary_mask)\n",
    "\n",
    "    # Remove small objects (noise)\n",
    "    cleaned = morphology.remove_small_objects(binary_mask, min_size=min_size)\n",
    "\n",
    "    # plt.imshow(cleaned)\n",
    "\n",
    "    # Fill holes in the remaining objects\n",
    "    filled = morphology.remove_small_holes(cleaned, area_threshold=area_threshold)\n",
    "    # plt.imshow(filled)\n",
    "\n",
    "    # Label connected components\n",
    "    # labeled_image = measure.label(filled)\n",
    "\n",
    "    # Create a color image for visualization\n",
    "    # color_image = color.label2rgb(labeled_image, image_float, bg_label=0)\n",
    "\n",
    "    binary_mask_front = ~filled\n",
    "    cleaned_zero = morphology.remove_small_objects(binary_mask_front, min_size=min_size_bkg)\n",
    "    \n",
    "    \n",
    "    if display:\n",
    "        # Display results\n",
    "        fig, axes = plt.subplots(2, 2, figsize=(12, 12))\n",
    "        ax = axes.ravel()\n",
    "\n",
    "        ax[0].imshow(image, cmap='gray')\n",
    "        ax[0].set_title('Original Image')\n",
    "\n",
    "        ax[1].imshow(binary_mask, cmap='gray')\n",
    "        ax[1].set_title('Binary Mask')\n",
    "\n",
    "        ax[2].imshow(filled, cmap='gray')\n",
    "        ax[2].set_title('Cleaned and Filled')\n",
    "\n",
    "        ax[3].imshow(color_image)\n",
    "        ax[3].set_title('Labeled Spheres')\n",
    "\n",
    "        for a in ax:\n",
    "            a.axis('off')\n",
    "\n",
    "        plt.tight_layout()\n",
    "        plt.show()\n",
    "\n",
    "        # Optional: Save the result\n",
    "        # io.imsave('spheres_isolated.png', (color_image * 255).astype(np.uint8))\n",
    "\n",
    "        # plt.imshow(np.where(labeled_image == 0, 1, 0))\n",
    "\n",
    "        # binary_mask_front = np.where(labeled_image == 0, True, False)\n",
    "\n",
    "        plt.figure()\n",
    "        plt.imshow(binary_mask_front)\n",
    "        plt.figure()\n",
    "        plt.imshow(np.logical_xor(cleaned_zero,binary_mask_front))\n",
    "        \n",
    "    # return cleaned_zero\n",
    "    spheres_only = np.logical_xor(cleaned_zero,binary_mask_front)\n",
    "    io.imsave('spheres_isolated.png', (spheres_only * 255).astype(np.uint8))\n",
    "    return spheres_only\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_182899/3206869778.py:108: UserWarning: spheres_isolated.png is a low contrast image\n",
      "  io.imsave('spheres_isolated.png', (spheres_only * 255).astype(np.uint8))\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fd9d4a97ee0>"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAasAAAGiCAYAAABZHumlAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAtGUlEQVR4nO3dfXRVZX73/88xD0dIky1JyDmcGpiMd1Q0GdTohDCOxAEC1BCorcBAM3gPRSwCZngQ+FkrujqJMB2wnRSflhUHtXH97mXQVhoJHYhSCGQCUUFErRkIQgij4YRATEJy3X94u+tJeBA8kIvwfq2118q+9ndvrq/74Id9zt45HmOMEQAAFruipycAAMDZEFYAAOsRVgAA6xFWAADrEVYAAOsRVgAA6xFWAADrEVYAAOsRVgAA6xFWAADrWR1Wq1atUkpKiq688kplZGTonXfe6ekpAQB6gLVh9eqrr6qgoEAPP/ywdu7cqR//+McaO3as9u/f39NTAwBcZB5bf5FtZmambrnlFj311FPu2ODBgzVhwgQVFRX14MwAABdbZE9P4FTa2tpUXV2txYsXh4zn5ORoy5Ytp9yntbVVra2t7npnZ6e++OILJSQkyOPxXND5AgDOjzFGx44dUyAQ0BVXnP7NPivD6o9//KM6Ojrk8/lCxn0+n+rr60+5T1FRkR577LGLMT0AQJjV1dXp6quvPu12K8Pqa12viIwxp71KWrJkiebNm+euB4NBDRw4ULfrzxSpqAs6TwDA+Tmpdm3WOsXGxp6xzsqwSkxMVERERLerqIaGhm5XW1/zer3yer3dxiMVpUgPYQUAVvp/d02c7eMaK+8GjI6OVkZGhsrLy0PGy8vLNWzYsB6aFQCgp1h5ZSVJ8+bNU35+vm699VZlZWXp2Wef1f79+3X//ff39NQAABeZtWE1adIkff7553r88cd16NAhpaWlad26dRo0aFBPTw0AcJFZ+5zVd9XU1CTHcZSt8XxmBQCWOmnatUmvKxgMKi4u7rR1Vn5mBQDANxFWAADrEVYAAOsRVgAA6xFWAADrEVYAAOsRVgAA6xFWAADrEVYAAOsRVgAA6xFWAADrEVYAAOsRVgAA6xFWAADrEVa4fHk8ivhfKYpMGSSd5Su1AfQswgqXJY/Xq0+XDdXi9aVauOHftP+RLHkirf0uUuCyR1jhstQyaoi2//TXuuNKKbtPpypm/ErNEzJ6eloAToOwwmWpJSFCcVdc6a4nRcSoMTWiB2cE4EwIK1yW4j9oVmXr/6w3d36pPzlgem5CAM6IN+lxWTJV72vh/zdL35uzV0lXHtO69bfpmv9/pzp7emIATomwwmUrtqRSX/yfSH3huUIp7VsJKsBihBUua+bkyZ6eAoBvgc+sAADWI6wAANYjrAAA1iOsAADWI6wAANYjrAAA1iOsAADWI6wAANYjrAAA1iOsAADWC3tYFRUV6bbbblNsbKySkpI0YcIE7d27N6TGGKOlS5cqEAioT58+ys7O1u7du0NqWltbNWfOHCUmJiomJkZ5eXk6cOBAuKcLALgEhD2sKioq9MADD6iyslLl5eU6efKkcnJydPz4cbdm+fLlWrFihYqLi1VVVSW/369Ro0bp2LFjbk1BQYFKS0tVUlKizZs3q7m5Wbm5uero6Aj3lAEAlvMYYy7ol/gcOXJESUlJqqio0B133CFjjAKBgAoKCrRo0SJJX11F+Xw+LVu2TDNnzlQwGFT//v21Zs0aTZo0SZJ08OBBJScna926dRo9evRZ/9ympiY5jqNsjVekJ+pCtggAOE8nTbs26XUFg0HFxcWdtu6Cf2YVDAYlSfHx8ZKk2tpa1dfXKycnx63xer0aPny4tmzZIkmqrq5We3t7SE0gEFBaWppb01Vra6uamppCFgBA73BBw8oYo3nz5un2229XWlqaJKm+vl6S5PP5Qmp9Pp+7rb6+XtHR0erXr99pa7oqKiqS4zjukpycHO52AAA95IKG1ezZs/Xee+/pX//1X7tt83g8IevGmG5jXZ2pZsmSJQoGg+5SV1d3/hMHAFjlgoXVnDlz9MYbb2jjxo26+uqr3XG/3y9J3a6QGhoa3Kstv9+vtrY2NTY2nramK6/Xq7i4uJAFANA7hD2sjDGaPXu2XnvtNf3ud79TSkpKyPaUlBT5/X6Vl5e7Y21tbaqoqNCwYcMkSRkZGYqKigqpOXTokHbt2uXWAAAuH2H/WvsHHnhAr7zyil5//XXFxsa6V1CO46hPnz7yeDwqKChQYWGhUlNTlZqaqsLCQvXt21dTpkxxa6dPn6758+crISFB8fHxWrBggdLT0zVy5MhwTxkAYLmwh9VTTz0lScrOzg4Zf+GFF3TvvfdKkh566CG1tLRo1qxZamxsVGZmptavX6/Y2Fi3fuXKlYqMjNTEiRPV0tKiESNGaPXq1YqIiAj3lAEAlrvgz1n1FJ6zAgD7WfOcFQAA3xVhBQCwHmEFALAeYQUAsB5hBQCwHmEFALAeYQUAsB5hBQCwHmEFALAeYQUAsB5hBQCwHmEFALAeYQUAsB5hBQCwXti/zwqwhScqWkpLlae9Q52790q989twgMsCYYXeyePRHx7J0H9M+5WCnVGa9uQv5P/HLed0iCv69tVnf3OTvkw0uubVoDprPrhAkwVwNrwNiF7pir59NWn820qJ+hPd5PXqzp9tl8frPadj7Jt/kyp/8aQ+mvaUfvTbHYr808AFmi2AsyGs0CuZ1la99dlgd/2TY/2lznN4G9DjUWRGo/peES1JWpSwWwfu+V6YZwng2yKs0CuZkyeVMPukrvnP/61r3/6ZTs6Pl2lvO4cDGHlfv0p/7DguSYryROjhWS/L/OimCzNhAGdEWKHXOvnpH/S/8ncqZfJ7MtW7z3n/hDVVynp5gdpNhyRp4p8E1fHYF/JE8lEvcLERVsBpmJMnde1TB7S+JcYduzVhvxQR0YOzAi5PhBVwBif3H1DB//nf+qj9uP67vVlr/z1LprW1p6cFXHZ4PwM4E2N0zd9W6cGSGZKklF1V4mkt4OIjrICzMCdPyvCMFdCjeBsQAGA9wgoAYD3CCgBgPcIKAGA9wgoAYD3CCgBgPcIKAGC9Cx5WRUVF8ng8KigocMeMMVq6dKkCgYD69Omj7Oxs7d4d+rvbWltbNWfOHCUmJiomJkZ5eXk6cODAhZ4uAMBCFzSsqqqq9Oyzz+oHP/hByPjy5cu1YsUKFRcXq6qqSn6/X6NGjdKxY8fcmoKCApWWlqqkpESbN29Wc3OzcnNz1dHRcSGnDACw0AULq+bmZk2dOlXPPfec+vXr544bY/Tkk0/q4Ycf1t133620tDS9+OKLOnHihF555RVJUjAY1PPPP69f//rXGjlypG6++Wa99NJLev/997Vhw4YLNWUAgKUuWFg98MADuuuuuzRy5MiQ8draWtXX1ysnJ8cd83q9Gj58uLZs+eprx6urq9Xe3h5SEwgElJaW5tZ01draqqamppAFANA7XJDfDVhSUqIdO3aoqqqq27b6+npJks/nCxn3+Xzat2+fWxMdHR1yRfZ1zdf7d1VUVKTHHnssHNMHAFgm7FdWdXV1evDBB/XSSy/pyiuvPG2dx+MJWTfGdBvr6kw1S5YsUTAYdJe6urpznzwAwEphD6vq6mo1NDQoIyNDkZGRioyMVEVFhf7pn/5JkZGR7hVV1yukhoYGd5vf71dbW5saGxtPW9OV1+tVXFxcyAIA6B3CHlYjRozQ+++/r5qaGne59dZbNXXqVNXU1Oj73/++/H6/ysvL3X3a2tpUUVGhYcOGSZIyMjIUFRUVUnPo0CHt2rXLrQEAXD7C/plVbGys0tLSQsZiYmKUkJDgjhcUFKiwsFCpqalKTU1VYWGh+vbtqylTpkiSHMfR9OnTNX/+fCUkJCg+Pl4LFixQenp6txs2AAC9X498+eJDDz2klpYWzZo1S42NjcrMzNT69esVGxvr1qxcuVKRkZGaOHGiWlpaNGLECK1evVoRERE9MWUAQA/yGGN65bd0NzU1yXEcZWu8Ij1RPT0dAMApnDTt2qTXFQwGz3ivAb8bEABgPcIKAGA9wgoAYD3CCgBgPcIKAGA9wgoAYD3CCgBgPcIKAGA9wgoAYD3CCgBgPcIKAGA9wgoAYD3CCgBgPcIKAGA9wgoAYD3CCgBgPcIKAGA9wgoAYD3CCgBgPcIKAGA9wgoAYD3CCgBgPcIKAGA9wgoAYD3CCgBgPcIKAGA9wgoAYD3CCgBgPcIKAGA9wgoAYD3CCgBgPcIKAGC9CxJWn332mf7qr/5KCQkJ6tu3r2666SZVV1e7240xWrp0qQKBgPr06aPs7Gzt3r075Bitra2aM2eOEhMTFRMTo7y8PB04cOBCTBcAYLmwh1VjY6N+9KMfKSoqSv/xH/+hDz74QL/+9a911VVXuTXLly/XihUrVFxcrKqqKvn9fo0aNUrHjh1zawoKClRaWqqSkhJt3rxZzc3Nys3NVUdHR7inDACwnMcYY8J5wMWLF+u//uu/9M4775xyuzFGgUBABQUFWrRokaSvrqJ8Pp+WLVummTNnKhgMqn///lqzZo0mTZokSTp48KCSk5O1bt06jR49+qzzaGpqkuM4ytZ4RXqiwtcgACBsTpp2bdLrCgaDiouLO21d2K+s3njjDd1666265557lJSUpJtvvlnPPfecu722tlb19fXKyclxx7xer4YPH64tW7ZIkqqrq9Xe3h5SEwgElJaW5tZ01draqqamppAFANA7hD2sPv30Uz311FNKTU3VW2+9pfvvv19z587Vb3/7W0lSfX29JMnn84Xs5/P53G319fWKjo5Wv379TlvTVVFRkRzHcZfk5ORwtwYA6CFhD6vOzk7dcsstKiws1M0336yZM2dqxowZeuqpp0LqPB5PyLoxpttYV2eqWbJkiYLBoLvU1dV9t0YAANYIe1gNGDBAN9xwQ8jY4MGDtX//fkmS3++XpG5XSA0NDe7Vlt/vV1tbmxobG09b05XX61VcXFzIAgDoHcIeVj/60Y+0d+/ekLGPPvpIgwYNkiSlpKTI7/ervLzc3d7W1qaKigoNGzZMkpSRkaGoqKiQmkOHDmnXrl1uDQDg8hEZ7gP+4he/0LBhw1RYWKiJEydq+/btevbZZ/Xss89K+urtv4KCAhUWFio1NVWpqakqLCxU3759NWXKFEmS4ziaPn265s+fr4SEBMXHx2vBggVKT0/XyJEjwz1lAIDlwh5Wt912m0pLS7VkyRI9/vjjSklJ0ZNPPqmpU6e6NQ899JBaWlo0a9YsNTY2KjMzU+vXr1dsbKxbs3LlSkVGRmrixIlqaWnRiBEjtHr1akVERIR7ygAAy4X9OStb8JwVANivx56zAgAg3AgrAID1CCsAgPUIKwCA9QgrAID1CCsAgPUIKwCA9QgrAID1CCsAgPUIKwCA9QgrAID1CCsAgPUIKwCA9QgrAID1CCsAgPUIKwCA9QgrAID1CCsAgPUIKwCA9QgrAID1CCsAgPUIKwCA9QgrAID1CCsAgPUIKwCA9QgrAID1CCsAgPUIKwCA9QgrAID1CCsAgPUIKwCA9QgrAID1wh5WJ0+e1N/+7d8qJSVFffr00fe//309/vjj6uzsdGuMMVq6dKkCgYD69Omj7Oxs7d69O+Q4ra2tmjNnjhITExUTE6O8vDwdOHAg3NMFAFwCwh5Wy5Yt09NPP63i4mLt2bNHy5cv169+9Sv95je/cWuWL1+uFStWqLi4WFVVVfL7/Ro1apSOHTvm1hQUFKi0tFQlJSXavHmzmpublZubq46OjnBPGQBgOY8xxoTzgLm5ufL5fHr++efdsb/4i79Q3759tWbNGhljFAgEVFBQoEWLFkn66irK5/Np2bJlmjlzpoLBoPr37681a9Zo0qRJkqSDBw8qOTlZ69at0+jRo886j6amJjmOo2yNV6QnKpwtAgDC5KRp1ya9rmAwqLi4uNPWhf3K6vbbb9d//ud/6qOPPpIkvfvuu9q8ebP+7M/+TJJUW1ur+vp65eTkuPt4vV4NHz5cW7ZskSRVV1ervb09pCYQCCgtLc2t6aq1tVVNTU0hCwCgd4gM9wEXLVqkYDCo66+/XhEREero6NAvf/lL/fSnP5Uk1dfXS5J8Pl/Ifj6fT/v27XNroqOj1a9fv241X+/fVVFRkR577LFwtwMAsEDYr6xeffVVvfTSS3rllVe0Y8cOvfjii/qHf/gHvfjiiyF1Ho8nZN0Y022sqzPVLFmyRMFg0F3q6uq+WyMAAGuE/cpq4cKFWrx4sSZPnixJSk9P1759+1RUVKRp06bJ7/dL+urqacCAAe5+DQ0N7tWW3+9XW1ubGhsbQ66uGhoaNGzYsFP+uV6vV16vN9ztAAAsEPYrqxMnTuiKK0IPGxER4d66npKSIr/fr/Lycnd7W1ubKioq3CDKyMhQVFRUSM2hQ4e0a9eu04YVAKD3CvuV1bhx4/TLX/5SAwcO1I033qidO3dqxYoV+vnPfy7pq7f/CgoKVFhYqNTUVKWmpqqwsFB9+/bVlClTJEmO42j69OmaP3++EhISFB8frwULFig9PV0jR44M95QBAJYLe1j95je/0SOPPKJZs2apoaFBgUBAM2fO1N/93d+5NQ899JBaWlo0a9YsNTY2KjMzU+vXr1dsbKxbs3LlSkVGRmrixIlqaWnRiBEjtHr1akVERIR7ygAAy4X9OStb8JwVANivx56zAgAg3AgrAID1CCsAgPUIKwCA9QgrAID1CCsAgPUIKwCA9QgrAID1CCsAgPUIKwCA9QgrAID1CCsAgPUIKwCA9QgrAID1CCsAgPUIKwCA9QgrAID1CCsAgPUIKwCA9QgrAID1CCsAgPUIKwCA9QgrAID1CCsAgPUIKwCA9QgrAID1CCsAgPUIKwCA9QgrAID1CCsAgPUIKwCA9QgrAID1zjms3n77bY0bN06BQEAej0dr164N2W6M0dKlSxUIBNSnTx9lZ2dr9+7dITWtra2aM2eOEhMTFRMTo7y8PB04cCCkprGxUfn5+XIcR47jKD8/X0ePHj3nBgEAl75zDqvjx49ryJAhKi4uPuX25cuXa8WKFSouLlZVVZX8fr9GjRqlY8eOuTUFBQUqLS1VSUmJNm/erObmZuXm5qqjo8OtmTJlimpqalRWVqaysjLV1NQoPz//PFoEAFzqPMYYc947ezwqLS3VhAkTJH11VRUIBFRQUKBFixZJ+uoqyufzadmyZZo5c6aCwaD69++vNWvWaNKkSZKkgwcPKjk5WevWrdPo0aO1Z88e3XDDDaqsrFRmZqYkqbKyUllZWfrwww913XXXdZtLa2urWltb3fWmpiYlJycrW+MV6Yk63xYBABfQSdOuTXpdwWBQcXFxp60L62dWtbW1qq+vV05Ojjvm9Xo1fPhwbdmyRZJUXV2t9vb2kJpAIKC0tDS3ZuvWrXIcxw0qSRo6dKgcx3FruioqKnLfMnQcR8nJyeFsDQDQg8IaVvX19ZIkn88XMu7z+dxt9fX1io6OVr9+/c5Yk5SU1O34SUlJbk1XS5YsUTAYdJe6urrv3A8AwA6RF+KgHo8nZN0Y022sq641p6o/03G8Xq+8Xu95zBYAYLuwXln5/X5J6nb109DQ4F5t+f1+tbW1qbGx8Yw1hw8f7nb8I0eOdLtqAwD0fmENq5SUFPn9fpWXl7tjbW1tqqio0LBhwyRJGRkZioqKCqk5dOiQdu3a5dZkZWUpGAxq+/btbs22bdsUDAbdGgDA5eOc3wZsbm7WJ5984q7X1taqpqZG8fHxGjhwoAoKClRYWKjU1FSlpqaqsLBQffv21ZQpUyRJjuNo+vTpmj9/vhISEhQfH68FCxYoPT1dI0eOlCQNHjxYY8aM0YwZM/TMM89Iku677z7l5uae8k5AAEDvds5h9fvf/1533nmnuz5v3jxJ0rRp07R69Wo99NBDamlp0axZs9TY2KjMzEytX79esbGx7j4rV65UZGSkJk6cqJaWFo0YMUKrV69WRESEW/Pyyy9r7ty57l2DeXl5p322CwDQu32n56xs1tTUJMdxeM4KACzWI89ZAQBwIRBWAADrEVYAAOsRVgAA6xFWAADrEVYAAOsRVgAA6xFWAADrEVYAAOsRVgAA6xFWAADrEVYAAOsRVgAA6xFWAADrEVYAAOsRVgAA6xFWAADrEVYAAOsRVgAA6xFWAADrEVYAAOsRVgAA6xFWAADrEVYAAOsRVgAA6xFWAADrEVYAAOsRVgAA6xFWAADrEVYAAOsRVgAA651zWL399tsaN26cAoGAPB6P1q5d625rb2/XokWLlJ6erpiYGAUCAf3sZz/TwYMHQ47R2tqqOXPmKDExUTExMcrLy9OBAwdCahobG5Wfny/HceQ4jvLz83X06NHzahIAcGk757A6fvy4hgwZouLi4m7bTpw4oR07duiRRx7Rjh079Nprr+mjjz5SXl5eSF1BQYFKS0tVUlKizZs3q7m5Wbm5uero6HBrpkyZopqaGpWVlamsrEw1NTXKz88/jxYBAJc6jzHGnPfOHo9KS0s1YcKE09ZUVVXphz/8ofbt26eBAwcqGAyqf//+WrNmjSZNmiRJOnjwoJKTk7Vu3TqNHj1ae/bs0Q033KDKykplZmZKkiorK5WVlaUPP/xQ11133Vnn1tTUJMdxlK3xivREnW+LAIAL6KRp1ya9rmAwqLi4uNPWXfDPrILBoDwej6666ipJUnV1tdrb25WTk+PWBAIBpaWlacuWLZKkrVu3ynEcN6gkaejQoXIcx63pqrW1VU1NTSELAKB3uKBh9eWXX2rx4sWaMmWKm5j19fWKjo5Wv379Qmp9Pp/q6+vdmqSkpG7HS0pKcmu6Kioqcj/fchxHycnJYe4GANBTLlhYtbe3a/Lkyers7NSqVavOWm+Mkcfjcde/+fPpar5pyZIlCgaD7lJXV3f+kwcAWOWChFV7e7smTpyo2tpalZeXh7wP6ff71dbWpsbGxpB9Ghoa5PP53JrDhw93O+6RI0fcmq68Xq/i4uJCFgBA7xD2sPo6qD7++GNt2LBBCQkJIdszMjIUFRWl8vJyd+zQoUPatWuXhg0bJknKyspSMBjU9u3b3Zpt27YpGAy6NQCAy0fkue7Q3NysTz75xF2vra1VTU2N4uPjFQgE9Jd/+ZfasWOH/v3f/10dHR3uZ0zx8fGKjo6W4ziaPn265s+fr4SEBMXHx2vBggVKT0/XyJEjJUmDBw/WmDFjNGPGDD3zzDOSpPvuu0+5ubnf6k5AAEDvcs63rm/atEl33nlnt/Fp06Zp6dKlSklJOeV+GzduVHZ2tqSvbrxYuHChXnnlFbW0tGjEiBFatWpVyE0RX3zxhebOnas33nhDkpSXl6fi4mL3rsKz4dZ1ALDft711/Ts9Z2UzwgoA7GfNc1YAAHxXhBUAwHqEFQDAeoQVAMB6hBUAwHqEFQDAeoQVAMB6hBUAwHqEFQDAeoQVAMB6hBUAwHqEFQDAeoQVAMB6hBUAwHqEFQDAeoQVAMB6hBUAwHqEFQDAeoQVAMB6hBUAwHqEFQDAeoQVAMB6hBUAwHqEFQDAeoQVAMB6hBUAwHqEFQDAeoQVAMB6hBUAwHqEFQDAeoQVAMB6hBUAwHrnHFZvv/22xo0bp0AgII/Ho7Vr1562dubMmfJ4PHryySdDxltbWzVnzhwlJiYqJiZGeXl5OnDgQEhNY2Oj8vPz5TiOHMdRfn6+jh49eq7TBQD0AuccVsePH9eQIUNUXFx8xrq1a9dq27ZtCgQC3bYVFBSotLRUJSUl2rx5s5qbm5Wbm6uOjg63ZsqUKaqpqVFZWZnKyspUU1Oj/Pz8c50uAKAXiDzXHcaOHauxY8eeseazzz7T7Nmz9dZbb+muu+4K2RYMBvX8889rzZo1GjlypCTppZdeUnJysjZs2KDRo0drz549KisrU2VlpTIzMyVJzz33nLKysrR3715dd9115zptAMAlLOyfWXV2dio/P18LFy7UjTfe2G17dXW12tvblZOT444FAgGlpaVpy5YtkqStW7fKcRw3qCRp6NChchzHremqtbVVTU1NIQsAoHcIe1gtW7ZMkZGRmjt37im319fXKzo6Wv369QsZ9/l8qq+vd2uSkpK67ZuUlOTWdFVUVOR+vuU4jpKTk79jJwAAW4Q1rKqrq/WP//iPWr16tTwezznta4wJ2edU+3et+aYlS5YoGAy6S11d3blNHgBgrbCG1TvvvKOGhgYNHDhQkZGRioyM1L59+zR//nx973vfkyT5/X61tbWpsbExZN+Ghgb5fD635vDhw92Of+TIEbemK6/Xq7i4uJAFANA7hDWs8vPz9d5776mmpsZdAoGAFi5cqLfeekuSlJGRoaioKJWXl7v7HTp0SLt27dKwYcMkSVlZWQoGg9q+fbtbs23bNgWDQbcGAHD5OOe7AZubm/XJJ5+467W1taqpqVF8fLwGDhyohISEkPqoqCj5/X73Dj7HcTR9+nTNnz9fCQkJio+P14IFC5Senu7eHTh48GCNGTNGM2bM0DPPPCNJuu+++5Sbm8udgABwGTrnsPr973+vO++8012fN2+eJGnatGlavXr1tzrGypUrFRkZqYkTJ6qlpUUjRozQ6tWrFRER4da8/PLLmjt3rnvXYF5e3lmf7QIA9E4eY4zp6UlcCE1NTXIcR9kar0hPVE9PBwBwCidNuzbpdQWDwTPea8DvBgQAWI+wAgBYj7ACAFiPsAIAWI+wAgBYj7ACAFiPsAIAWI+wAgBYj7ACAFiPsAIAWI+wAgBYj7ACAFiPsAIAWI+wAgBYj7ACAFiPsAIAWI+wAgBYj7ACAFiPsAIAWI+wAgBYj7ACAFiPsAIAWI+wAgBYj7ACAFiPsAIAWI+wAgBYj7ACAFiPsAIAWI+wAgBYj7ACAFiPsAIAWI+wAgBY75zD6u2339a4ceMUCATk8Xi0du3abjV79uxRXl6eHMdRbGyshg4dqv3797vbW1tbNWfOHCUmJiomJkZ5eXk6cOBAyDEaGxuVn58vx3HkOI7y8/N19OjRc24QAHDpO+ewOn78uIYMGaLi4uJTbv/v//5v3X777br++uu1adMmvfvuu3rkkUd05ZVXujUFBQUqLS1VSUmJNm/erObmZuXm5qqjo8OtmTJlimpqalRWVqaysjLV1NQoPz//PFoEAFzqPMYYc947ezwqLS3VhAkT3LHJkycrKipKa9asOeU+wWBQ/fv315o1azRp0iRJ0sGDB5WcnKx169Zp9OjR2rNnj2644QZVVlYqMzNTklRZWamsrCx9+OGHuu666846t6amJjmOo2yNV6Qn6nxbBABcQCdNuzbpdQWDQcXFxZ22LqyfWXV2durNN9/Utddeq9GjRyspKUmZmZkhbxVWV1ervb1dOTk57lggEFBaWpq2bNkiSdq6dascx3GDSpKGDh0qx3Hcmq5aW1vV1NQUsgAAeoewhlVDQ4Oam5v1xBNPaMyYMVq/fr3+/M//XHfffbcqKiokSfX19YqOjla/fv1C9vX5fKqvr3drkpKSuh0/KSnJremqqKjI/XzLcRwlJyeHszUAQA8K+5WVJI0fP16/+MUvdNNNN2nx4sXKzc3V008/fcZ9jTHyeDzu+jd/Pl3NNy1ZskTBYNBd6urqvkMnAACbhDWsEhMTFRkZqRtuuCFkfPDgwe7dgH6/X21tbWpsbAypaWhokM/nc2sOHz7c7fhHjhxxa7ryer2Ki4sLWQAAvUNYwyo6Olq33Xab9u7dGzL+0UcfadCgQZKkjIwMRUVFqby83N1+6NAh7dq1S8OGDZMkZWVlKRgMavv27W7Ntm3bFAwG3RoAwOUj8lx3aG5u1ieffOKu19bWqqamRvHx8Ro4cKAWLlyoSZMm6Y477tCdd96psrIy/du//Zs2bdokSXIcR9OnT9f8+fOVkJCg+Ph4LViwQOnp6Ro5cqSkr67ExowZoxkzZuiZZ56RJN13333Kzc39VncCAgB6l3O+dX3Tpk268847u41PmzZNq1evliT9y7/8i4qKinTgwAFdd911euyxxzR+/Hi39ssvv9TChQv1yiuvqKWlRSNGjNCqVatCbor44osvNHfuXL3xxhuSpLy8PBUXF+uqq676VvPk1nUAsN+3vXX9Oz1nZTPCCgDs1yPPWQEAcCEQVgAA6xFWAADrEVYAAOsRVgAA6xFWAADrEVYAAOsRVgAA6xFWAADrEVYAAOsRVgAA6xFWAADrEVYAAOsRVgAA6xFWAADrEVYAAOsRVgAA6xFWAADrEVYAAOtF9vQELhRjjCTppNol08OTAQCc0km1S/qf/2efTq8Nq88//1yStFnrengmAICzOXbsmBzHOe32XhtW8fHxkqT9+/ef8T/ApaapqUnJycmqq6tTXFxcT08nLHpjT1Lv7IueLh2XSl/GGB07dkyBQOCMdb02rK644quP4xzHsfpEna+4uLhe11dv7EnqnX3R06XjUujr21xQcIMFAMB6hBUAwHq9Nqy8Xq8effRReb3enp5KWPXGvnpjT1Lv7IueLh29rS+POdv9ggAA9LBee2UFAOg9CCsAgPUIKwCA9QgrAID1CCsAgPV6bVitWrVKKSkpuvLKK5WRkaF33nmnp6d0SkVFRbrtttsUGxurpKQkTZgwQXv37g2puffee+XxeEKWoUOHhtS0trZqzpw5SkxMVExMjPLy8nTgwIGL2UqIpUuXdpuz3+93txtjtHTpUgUCAfXp00fZ2dnavXt3yDFs6+l73/tet548Ho8eeOABSZfOeXr77bc1btw4BQIBeTwerV27NmR7uM5NY2Oj8vPz5TiOHMdRfn6+jh49etF7am9v16JFi5Senq6YmBgFAgH97Gc/08GDB0OOkZ2d3e38TZ48ucd6OltfUvhecxe7r/PRK8Pq1VdfVUFBgR5++GHt3LlTP/7xjzV27Fjt37+/p6fWTUVFhR544AFVVlaqvLxcJ0+eVE5Ojo4fPx5SN2bMGB06dMhd1q0L/QW9BQUFKi0tVUlJiTZv3qzm5mbl5uaqo6PjYrYT4sYbbwyZ8/vvv+9uW758uVasWKHi4mJVVVXJ7/dr1KhROnbsmFtjW09VVVUh/ZSXl0uS7rnnHrfmUjhPx48f15AhQ1RcXHzK7eE6N1OmTFFNTY3KyspUVlammpoa5efnX/SeTpw4oR07duiRRx7Rjh079Nprr+mjjz5SXl5et9oZM2aEnL9nnnkmZPvF7OlsfX0tHK+5i93XeTG90A9/+ENz//33h4xdf/31ZvHixT00o2+voaHBSDIVFRXu2LRp08z48eNPu8/Ro0dNVFSUKSkpccc+++wzc8UVV5iysrILOd3TevTRR82QIUNOua2zs9P4/X7zxBNPuGNffvmlcRzHPP3008YYO3vq6sEHHzTXXHON6ezsNMZcmudJkiktLXXXw3VuPvjgAyPJVFZWujVbt241ksyHH354UXs6le3btxtJZt++fe7Y8OHDzYMPPnjafXqyJ2NO3Vc4XnM93de31euurNra2lRdXa2cnJyQ8ZycHG3ZsqWHZvXtBYNBSf/zW+O/tmnTJiUlJenaa6/VjBkz1NDQ4G6rrq5We3t7SM+BQEBpaWk92vPHH3+sQCCglJQUTZ48WZ9++qkkqba2VvX19SHz9Xq9Gj58uDtfW3v6Wltbm1566SX9/Oc/l8fjcccvxfP0TeE6N1u3bpXjOMrMzHRrhg4dKsdxrOg1GAzK4/HoqquuChl/+eWXlZiYqBtvvFELFiwIuZq0tafv+pqzta+uet1vXf/jH/+ojo4O+Xy+kHGfz6f6+voemtW3Y4zRvHnzdPvttystLc0dHzt2rO655x4NGjRItbW1euSRR/STn/xE1dXV8nq9qq+vV3R0tPr16xdyvJ7sOTMzU7/97W917bXX6vDhw/r7v/97DRs2TLt373bndKpztG/fPkmysqdvWrt2rY4ePap7773XHbsUz1NX4To39fX1SkpK6nb8pKSkHu/1yy+/1OLFizVlypSQ30Y+depUpaSkyO/3a9euXVqyZIneffdd9+1eG3sKx2vOxr5OpdeF1de++a9d6asg6Dpmm9mzZ+u9997T5s2bQ8YnTZrk/pyWlqZbb71VgwYN0ptvvqm77777tMfryZ7Hjh3r/pyenq6srCxdc801evHFF90PgM/nHNlyHp9//nmNHTs25Dt4LsXzdDrhODenqu/pXtvb2zV58mR1dnZq1apVIdtmzJjh/pyWlqbU1FTdeuut2rFjh2655RZJ9vUUrtecbX2dSq97GzAxMVERERHd/kXQ0NDQ7V+LNpkzZ47eeOMNbdy4UVdfffUZawcMGKBBgwbp448/liT5/X61tbWpsbExpM6mnmNiYpSenq6PP/7YvSvwTOfI5p727dunDRs26K//+q/PWHcpnqdwnRu/36/Dhw93O/6RI0d6rNf29nZNnDhRtbW1Ki8vP+t3PN1yyy2KiooKOX+29dTV+bzmLoW+pF4YVtHR0crIyHAv3b9WXl6uYcOG9dCsTs8Yo9mzZ+u1117T7373O6WkpJx1n88//1x1dXUaMGCAJCkjI0NRUVEhPR86dEi7du2ypufW1lbt2bNHAwYMcN9q+eZ829raVFFR4c7X5p5eeOEFJSUl6a677jpj3aV4nsJ1brKyshQMBrV9+3a3Ztu2bQoGgz3S69dB9fHHH2vDhg1KSEg46z67d+9We3u7e/5s6+lUzuc1dyn0Jal33g1YUlJioqKizPPPP28++OADU1BQYGJiYswf/vCHnp5aN3/zN39jHMcxmzZtMocOHXKXEydOGGOMOXbsmJk/f77ZsmWLqa2tNRs3bjRZWVnmT//0T01TU5N7nPvvv99cffXVZsOGDWbHjh3mJz/5iRkyZIg5efJkj/Q1f/58s2nTJvPpp5+ayspKk5uba2JjY91z8MQTTxjHccxrr71m3n//ffPTn/7UDBgwwOqejDGmo6PDDBw40CxatChk/FI6T8eOHTM7d+40O3fuNJLMihUrzM6dO90748J1bsaMGWN+8IMfmK1bt5qtW7ea9PR0k5ube9F7am9vN3l5eebqq682NTU1IX/PWltbjTHGfPLJJ+axxx4zVVVVpra21rz55pvm+uuvNzfffHOP9XS2vsL5mrvYfZ2PXhlWxhjzz//8z2bQoEEmOjra3HLLLSG3gttE0imXF154wRhjzIkTJ0xOTo7p37+/iYqKMgMHDjTTpk0z+/fvDzlOS0uLmT17tomPjzd9+vQxubm53WoupkmTJpkBAwaYqKgoEwgEzN133212797tbu/s7DSPPvqo8fv9xuv1mjvuuMO8//77IcewrSdjjHnrrbeMJLN3796Q8UvpPG3cuPGUr7lp06YZY8J3bj7//HMzdepUExsba2JjY83UqVNNY2PjRe+ptrb2tH/PNm7caIwxZv/+/eaOO+4w8fHxJjo62lxzzTVm7ty55vPPP++xns7WVzhfcxe7r/PB91kBAKzX6z6zAgD0PoQVAMB6hBUAwHqEFQDAeoQVAMB6hBUAwHqEFQDAeoQVAMB6hBUAwHqEFQDAeoQVAMB6/xcPfPhQxvxeFgAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "image = io.imread('./image.jpg')  # Replace with your image path\n",
    "clean_image = remove_background(image)\n",
    "plt.imshow(clean_image)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pro_my_open_ptv_benchmark",
   "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.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}