tutorials/3-advanced-topics/DTAT301_features.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# deeptrack.features\n",
        "\n",
        "<a href=\"https://colab.research.google.com/github/DeepTrackAI/DeepTrack2/blob/develop/tutorials/3-advanced-topics/DTAT301_features.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {},
      "outputs": [],
      "source": [
        "# !pip install deeptrack  # Uncomment if running on Colab/Kaggle."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "This advanced tutorial introduces the module deeptrack.features."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {},
      "outputs": [],
      "source": [
        "from matplotlib import pyplot as plt\n",
        "import numpy as np"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 1. What is a Feature?\n",
        "\n",
        "Features are instances of the abstract class `Feature` and are responsible for creating and altering images. For example, a feature might add a particle or add some salt-and-pepper noise to an image.\n",
        "\n",
        "All features operate on lists of images (which can be either `Image` objects or numerical arrays). Most features, such as noise, apply some tranformation to all images in the list. This transformation can be additive, such as adding some Gaussian noise or a background illumination, or non-additive, such as introducing Poisson noise or performing a low-pass filter. This transformation is defined by the method `get(image, **kwargs)`, which all implementations of the class `Feature` need to define.\n",
        "\n",
        "Some features, for example scatterers, instead, append a new image to the list. This behavior is controlled by the class attributes `__distributed__` and `__list_merge_strategy__`:\n",
        "\n",
        "- `__distributed__` controls whether `.get(image, **kwargs)` is called on each element in the list separately (`__distributed__ = True`), or it is called on the list as a whole (`__distributed__ = False`).  \n",
        "\n",
        "- `__list_merge_strategy__` controls how the output of `.get(image, **kwargs)` is merged with the input list. It can be `MERGE_STRATEGY_OVERRIDE` (`0`, default), where the new list is output without merging with the input, or `MERGE_STRATEGY_APPEND` (`1`), where the new list is appended to the end of the input list.\n",
        "\n",
        "When a feature is created, keyword arguments can be passed to its constructor. These arguments are stored as properties (as a `PropertyDict`) of the feature (see also [properties_example](DTAT306_properties.ipynb)), which determine how the feature is resolved. When a feature is updated using the method `.update()`, all properties are updated by calling their respective methods `.update()`. When a feature is called, the current values of all properties are sent through the method `get(image, **kwargs)` as keyword arguments."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2022-06-29T20:32:41.429206Z",
          "iopub.status.busy": "2022-06-29T20:32:41.429206Z",
          "iopub.status.idle": "2022-06-29T20:32:44.938650Z",
          "shell.execute_reply": "2022-06-29T20:32:44.938150Z"
        }
      },
      "outputs": [],
      "source": [
        "from deeptrack.features import Feature\n",
        "\n",
        "class Foo(Feature):\n",
        "    \"\"\"Simple feature.\n",
        "    \n",
        "    Implementation of abstract class Feature which does not alter the input\n",
        "    image and prints the current value of my_property.\n",
        "\n",
        "    \"\"\"\n",
        "\n",
        "    # Controls what is passed to the method get(): \n",
        "    # False: everything is passed without modification.\n",
        "    # True: elements along the first axis are passed separately to the images.\n",
        "    __distributed__ = False\n",
        "\n",
        "    def get(self, image, my_property=None, **kwargs):\n",
        "        print(f\"The current value of my_property is {my_property}\")\n",
        "        return image"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The current value of my_property is 1\n",
            "[]\n"
          ]
        }
      ],
      "source": [
        "foo1 = Foo(my_property=1)\n",
        "foo1.update()\n",
        "output_image = foo1()\n",
        "print(output_image)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The current value of my_property is bar\n",
            "[]\n"
          ]
        }
      ],
      "source": [
        "foo2 = Foo(my_property=\"bar\")\n",
        "foo2.update()\n",
        "output_image = foo2()\n",
        "print(output_image)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The current value of my_property is None\n",
            "[]\n"
          ]
        }
      ],
      "source": [
        "foo3 = Foo()\n",
        "foo3.update()\n",
        "output_image = foo3()\n",
        "print(output_image)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Since the values are stored as instances of the class `Property`, you can always replace values with standard structures (e.g., lists or lambda functions) to create more complex behaviors (see also [properties_example](DTAT306_properties.ipynb))."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2022-06-29T20:32:44.941652Z",
          "iopub.status.busy": "2022-06-29T20:32:44.941151Z",
          "iopub.status.idle": "2022-06-29T20:32:44.943651Z",
          "shell.execute_reply": "2022-06-29T20:32:44.943651Z"
        }
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The current value of my_property is 0.1209843758525152\n",
            "[]\n"
          ]
        }
      ],
      "source": [
        "foo4 = Foo(my_property=lambda: np.random.rand() - 0.5)\n",
        "foo4.update()\n",
        "output_image = foo4()\n",
        "print(output_image)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The current value of my_property is bar\n",
            "[]\n"
          ]
        }
      ],
      "source": [
        "# Pick one random element from the list.\n",
        "foo5 = Foo(my_property=lambda: np.random.choice([\"bar\", \"baz\"]))\n",
        "foo5.update()\n",
        "output_image = foo5()\n",
        "print(output_image)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 2. Operations Defined on Features\n",
        "\n",
        "Features can be combined to create a feature series, which is a series of features that are evaluated sequentially."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Chaining features (>>)\n",
        "\n",
        "The rshft operator (>>) combines two features such that they are evaluated sequentially. For example, given the features `foo` and `bar`, you can combine them as `foobar = foo >> bar`. When `foobar` resolves an image, it first resolves an image from `foo`, then uses this image as the input to resolve an image from `bar`.\n",
        "\n",
        "This operation returns an instance of the feature `Branch`, which contains the two features."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2022-06-29T20:32:44.946650Z",
          "iopub.status.busy": "2022-06-29T20:32:44.946151Z",
          "iopub.status.idle": "2022-06-29T20:32:44.948650Z",
          "shell.execute_reply": "2022-06-29T20:32:44.948650Z"
        }
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The current value of my_property is foo\n",
            "The current value of my_property is bar\n",
            "[]\n"
          ]
        }
      ],
      "source": [
        "foobar = Foo(my_property=\"foo\") >> Foo(my_property=\"bar\")\n",
        "\n",
        "foobar.update()\n",
        "output_image = foobar()\n",
        "print(output_image)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Repeating a feature (^) \n",
        "\n",
        "The xor operator (^) takes a feature `foo` and an integer `i` and creates a feature which will call the feature `i` times with different sets of properties. For example, `foo ^ 5` will call Foo five times. Since this is done at resolve time, the exponent can be any expression that returns an integer when evaluated.\n",
        "\n",
        "This operation returns an instance of the feature `Repeat`, which contains the original feature and the number of times it should be repeated."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2022-06-29T20:32:44.952150Z",
          "iopub.status.busy": "2022-06-29T20:32:44.952150Z",
          "iopub.status.idle": "2022-06-29T20:32:44.954151Z",
          "shell.execute_reply": "2022-06-29T20:32:44.954151Z"
        }
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The current value of my_property is bar\n",
            "The current value of my_property is bar\n",
            "The current value of my_property is quux\n",
            "The current value of my_property is quux\n",
            "The current value of my_property is bar\n",
            "[]\n"
          ]
        }
      ],
      "source": [
        "foo = Foo(my_property=lambda: np.random.choice([\"bar\", \"baz\", \"qux\", \"quux\"])) \n",
        "\n",
        "five_foos = foo ^ 5\n",
        "five_foos.update()\n",
        "output_image = five_foos()\n",
        "print(output_image)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2022-06-29T20:32:44.957150Z",
          "iopub.status.busy": "2022-06-29T20:32:44.956652Z",
          "iopub.status.idle": "2022-06-29T20:32:44.959150Z",
          "shell.execute_reply": "2022-06-29T20:32:44.959150Z"
        }
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[]\n"
          ]
        }
      ],
      "source": [
        "number_of_foo = lambda: np.random.randint(0, 10)\n",
        "random_foos = foo ^ number_of_foo  # Pick one random exponent from the list.\n",
        "\n",
        "random_foos.update()\n",
        "output_image = random_foos()\n",
        "print(output_image)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 3. Example - Image with Random Circles"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Simple example that generates an image with some random circles."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2022-06-29T20:32:44.963649Z",
          "iopub.status.busy": "2022-06-29T20:32:44.963151Z",
          "iopub.status.idle": "2022-06-29T20:32:45.102680Z",
          "shell.execute_reply": "2022-06-29T20:32:45.102152Z"
        }
      },
      "outputs": [],
      "source": [
        "class Circle(Feature):\n",
        "    \"\"\"Feature that adds a circle to the image.\"\"\"\n",
        "\n",
        "    def get(self, image, position, radius, intensity, **kwargs):\n",
        "        X, Y = np.meshgrid(np.arange(image.shape[0]),\n",
        "                           np.arange(image.shape[1]))\n",
        "        mask = (X - position[0]) ** 2 + (Y - position[1]) ** 2 < radius ** 2\n",
        "        image[mask] = intensity\n",
        "        return image"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {},
      "outputs": [],
      "source": [
        "circle = Circle(\n",
        "    position=lambda: np.random.rand(2) * 512,\n",
        "    radius=lambda: 20 + np.random.rand() * 20,\n",
        "    intensity=1,\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {},
      "outputs": [],
      "source": [
        "circles = circle ^ 10  # Add 10 circles."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {},
      "outputs": [],
      "source": [
        "circles.update()\n",
        "\n",
        "input_image = np.zeros((512, 512))\n",
        "\n",
        "output_image = circles.resolve(input_image)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAa4AAAGiCAYAAAC/NyLhAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA9xElEQVR4nO3de1xUdd4H8M8MlxHEARQBb3gJlTXU0hKpttaVvKSJlzUj14ys1lupmW1spZW7D1pWlhbbZmmZZdpmeU/DS14IEUXFC+YVMgHTGEDlNvN9/uhxHkcRmYGZ3xz4vF+v7+ulc87M+cxhxo8znDmjExEBERGRRuhVByAiIrIHi4uIiDSFxUVERJrC4iIiIk1hcRERkaawuIiISFNYXEREpCksLiIi0hQWFxERaQqLi4iINEVZcb333nto06YNGjRogKioKOzatUtVFCIi0hAlxfXll1/i2WefxYwZM7Bnzx507doVffv2RX5+voo4RESkIToVJ9mNiorCnXfeifnz5wMALBYLWrVqhaeffhovvPCCq+MQEZGGeLp6g2VlZUhPT0dCQoL1Mr1ej5iYGKSkpFR6ndLSUpSWllr/brFYcOHCBTRp0gQ6nc7pmYmIqHaJCIqKitC8eXPo9fa9+efy4vr1119hNpsREhJic3lISAiOHDlS6XUSExPx6quvuiIeERG5UE5ODlq2bGnXdVxeXI5ISEjAs88+a/27yWRCWFiYwkSOW7duHe666y7VMSpVUlKCqKgonDp1SnWUOi8wMBC33347Xn/9dQBAo0aNEBoaetPrlZSUICcnBwCwY8cOzJ49GxUVFfz9MGlWo0aN7L6Oy4srKCgIHh4eyMvLs7k8Ly/vhk9cg8EAg8HginhOt337dvTp08ful8au4OXlhbNnz6qOUacNHz4c/v7+GD9+PG6//Xa7r280GhEcHAwA6N69O5555hnk5eXhpZdewrp163DmzJnajkzkVA79ukcU6NGjh0ycONH6d7PZLC1atJDExMRqXd9kMgkATY6fn5+UlZU5a9fWyKVLl8RgMCjfR3VxPDw8ZMyYMVJUVOS0n9+2bdtkxowZotPplN9fDqe6YzKZ7H6sK3mr8Nlnn8Xo0aNxxx13oEePHpg7dy4uXryI+Ph4FXHo/2RlZcFisaiOUed07doVGzduhNFodOo7B/fccw969uyJhg0b4vPPP0dGRobTtkWklBP+41ct8+bNk7CwMPH29pYePXrIjz/+WO3ravkVl7e3tyxevNiJe9ZxvXr1Ur5/6tIEBwfLK6+8IidOnHD5z7KoqEhiY2OV7wMO52bjyCsuZcVVE1ouLgDy4IMPqt6F1ykpKZF77rlH+b6pK9OwYUPZunWr0p/puXPnZNCgQXzrkOPW40hxud8RAvXAL7/8ghMnTqiOYWP+/PnYvn276hh1QqtWrbBq1Srce++9SnMEBQXh66+/xqBBg5TmIKptLC4F0tPT8d1336mOYXX27FksW7ZMdYw6wc/PD4sWLUKvXr1URwEAeHh4YMGCBYiNjVUdhaj2OOEdCqfT+luFACQgIECys7NV70oREVm/fr3y/VEXJigoSPnbgzdSWFgogwYNUr6POJxrh28VakhBQQG+/PJL1TEAAI8//rjqCHXCpEmTlL89eCONGjXCp59+Cg8PD9VRiGqMxaXQ9OnTMXfuXGWHoFssFsyePRvnz59Xsv265LbbbsPIkSNVx6hSw4YNMWPGDJYXaZ8T3pVwurrwVuGV8fDwkMTERKmoqHDpPiwrK5Pp06eLh4eH8n2g9fH09JRz58659OfnKLPZLPHx8cr3GYdzZfhWoQaZzWa8+OKLmDdvnku3+8Ybb2DmzJkwm80u3W5dNHr0aBiNRtUxqkWv1+ORRx5BQECA6ihEjnPCf+qcri694royPj4+MmfOHCkvL3fqvistLZV//etf0qBBA+X3uS6Mr6+vrF+/3qk/M2e47bbblO87DgfgB5DrxMyePdtp++3777+XhIQE5fexLs3YsWOd9vNypqNHjyrfdxwOwOKqE2MwGGT48OGyZcsWMZvNtbK/zGazfPfdd9K8eXPl968uTdOmTSU9Pb1WfkauVlRUJI899pjyfchx3uj1+irHXc6oopmT7NKNlZaWYvny5Vi7di0iIiLw73//Gx07dnToO2tMJhN++uknxMfH48SJE7h06ZITEtdfvr6+6Natm+oYDvHz88Ntt92mOgbVsiZNmqBt27Zo164d/v3vf1e57scff4ylS5fiwoULbncmn5vRiYioDmGvwsJC+Pv7q47hMvHx8WjTpg369++PO++8s8p18/PzrQ/Yn376CZ999pkrItZLrVu31vSXbv7444/461//iuPHj6uOQrXgb3/7G/r06YOhQ4fadb39+/fjv//9L958801cvHjRSeluzGQy2X1wE4tLQ9q0aYOQkJAq17l8+TL279/vokT126pVqzBw4EDVMWqkX79+bnX6MbLfPffcgzlz5qBz587w9fV1+Hb27NmDzz77DB9//DFMJlMtJqyaI8XF33FxOA7OsWPHVD8Vaqxv377K9yPH8bn33nvl4sWLtfZ4sFgsUlRUJPfdd5/L7gM/x0VEVA8EBQXhP//5Dz777LMavcq6lk6ng5+fHxYvXuw2J4quDN8qJHJA06ZNsXv3boSFhamOUiM///wzOnTogMuXL6uOQnZITU1Fjx49nLqNgoICDBw4EDt27HDqdhx5q5CvuIgcMH36dM2XFvB7Aet0OtUxyA69evVCeHi407cTEBCAVatWueUrLxYXEZFG9OzZE5988gkaN27sku0FBgYiLi4Oer17VYV7pSEiokp5eHigd+/eaNWqlUu3Gx8fjwEDBrh0mzfD4iIi0oBnnnkGr732msu36+npicceewwGg8Hl274RFheRAwoKCnhmfXKpoUOHKnvLLjY2FqGhoUq2XRkWF5EDXn75ZU2fNYO0pUuXLkqLw8PDw63OwsPiIqrH3njjDZSWlqqOQTcxYMAAlxxJWBW9Xu82R6CyuIjqse3bt/MtTzfn4+OD5s2bq46BHj16YPLkyapjAGBxERG5tY4dO2LixImqY8DT07NWz9JREywuIgc9/fTTqiPUyLJly5Camqo6BpHdWFxEDjp06JDqCDVy9uxZFBQUqI5BZDcWF5GDzp8/j88//1x1DIfk5+dj2bJlqmMQOYTFReSg4uJirF69GsXFxaqj2O3w4cPYuXOn6hhEDmFxEdXAF198ge+//151DLs9+uijqiMQOYzFRVRD//rXvzT1tSDz5s1Dfn6+6hhUTSdOnMCnn36qOoZbYXER1dDevXuRnp6uOka1/Prrr9iwYQNKSkpUR6FqKiwsxJEjR1THQGFhIU6fPq06BgAWF1GNmc1mPPzww9i0aZPqKDf1ww8/YPXq1apjkAbt37/fbU77xOIiqgVnzpzBxo0bUVFRoTrKDWVnZ2Pq1KmqY5ADFixYgIyMDKUZ3OmjEywuoloya9YsvPXWW6pjVGr//v3o3bs3TwysUefOncPKlSshIkq2X1FRgZEjRyrZdqVEg0wmkwDgcNxuDAaDvPPOO6qfIjaOHz8ukZGRyvcNp2bTqFEjKSsrU/IYmjNnjnh6ejrlfplMJrvz8BUXUS0qLS3F888/j9dff90t3jY8ceIE/vSnPyEzM1N1FKqh4uJijBkzxuXbPX/+PNasWeMWj+crWFxEtay0tBR///vf8e677yrNsW/fPsTGxiInJ0dpDqodIoK0tDTs3bvXZds0mUwYM2YMNm/e7LJtVkvtv6h0Pr5VyNHC+Pr6yttvvy1FRUUufX6UlJTIqVOnJDw8XPk+4NT+3HLLLXL8+HGXPJYOHTrk9PvjyFuFLC4Ox4mj1+ulYcOGsm3bNpc8N86dOydDhgxx2u8jOO4xLVq0kP379zv1sbR//35p2bKl0+8Li4vDcdMJCwuTcePGSX5+vtOeF++++648+OCDyu8rxzUTGRkpBw4ccMpj6cCBAy47oIfFxeG4+bRo0UImTJggx48flzNnztToeVBUVCTHjx+XLVu2SJs2baRBgwbK7x/H9Y+nAwcOyG+//VYr/7b+9ttvEhsbKyEhIS67D44Ul05E0QcDaqCwsBD+/v6qYxDVSJs2bTB16lT4+Pjg8ccfh06nq9b10tLSkJqaioyMDHz00UdOTklaMGjQIAwePBjx8fEO38bChQvx7bff4ttvv63FZDdnMplgNBrtug6Li0gxLy8v9OnTp9rFdfToURw9etTJqUhrvL29cf/992PKlCm49957odfr4eHhUem6ImI9vP2HH37A22+/jY0bN6KsrMyVkQGwuIiI6j2DwQAvLy8MHz4cjz32WKXrHDp0CNOmTQMAlJeXo7S01IUJbbG4iIhIUxwpLn4AmYiINIXFRUREmuKpOgAR2Uen08HX1xfvv/8+9Pqq/+85f/587Nq1S9lZxYmcgb/jItKAxo0bo2XLloiIiMC8efOg1+sRFBR00+sVFhaipKQES5YswaJFi2AymdzmW2yJAB6cQVQnPfnkk+jXrx+GDh1a49vKzMzEkiVL8P7776OwsLAW0hHVjCPFxTNncDhuOg0bNpQpU6bIpUuXav059PXXX4ufn594eHgov5+c+j38Pi6iOuKee+5Bbm4u5syZAx8fn1q//SFDhuDChQt4/vnnb/ghVSJ3xeIicjO9evXCF198AT8/v5sefFETXl5emDlzJiZPnuy0bRA5A48qJHIj99xzD5YvX44mTZq4ZHseHh745z//CU9PT7z11lsoLy93yXaJaoKvuIjcRK9evbB69WqXldYVDRo0wKxZszB16lSXbpfIUSwuIjeg0+kwevRopUfLvvLKK5g0aZKy7RNVF4uLSDFPT0+88MILeOSRR5TmMBgM6Nu3b7U+H0akEj/HRaRYYGAgfv31V6ceiGGPuLg4LF26tEa3ERERgVGjRuHChQt48803aykZ1UX8ADKRBn3xxRd4+OGHVcewOnnyJLp164aCgoKbrqvT6dCkSRPodDosX77c+rw0Go1o164dysrKcOjQIev6H330EZYuXYrS0lIUFRU56y6QhvADyByOxiYyMlKOHz+u+illw2KxyPDhw6uVPy4uTsxms1gsFrtuf9u2bRIXFycGg0H5z4Cjdhz5ALLdxbV161YZOHCgNGvWTADIihUrrntQvvzyyxIaGioNGjSQ3r17y9GjR23WOX/+vDzyyCPSqFEj8ff3l8cff1yKioqqnYHFxakr89prr9n7FHSJPXv2VJk7IiJCPvnkE/ntt99qtJ05c+Yo/xlw1I5Limvt2rXy4osvytdffy3A9cU1a9Ys8ff3l2+++Ub27dsngwYNkrZt28rly5et6/Tr10+6du0qP/74o2zbtk3Cw8MlLi6u2hlYXJy6MN27d7frP2yuVF5eLn//+98rzR0eHi5nzpypte3MnTtXOnXqJDqdTvnPhOP6cUlx2VwZtsVlsVgkNDRU3njjDetlBQUFYjAY5IsvvhARkUOHDgkASUtLs66zbt060el01X4ysLg4dWF69uxZk6ef082cOfO6zN26dZPDhw/X+rZKS0vloYceUv4z4bh+lJ+r8OTJk8jNzUVMTIz1Mn9/f0RFRSElJQUAkJKSgoCAANxxxx3WdWJiYqDX65Gamlrp7ZaWlqKwsNBmiLSuQYMGqiNUycvLy+ZIx1tuuQVffvklIiIian1b3t7eiI+Ph6cnT+ZDN1erxZWbmwsACAkJsbk8JCTEuiw3NxfBwcE2yz09PdG4cWPrOtdKTEyEv7+/dVq1alWbsYlczsPDA1999ZXqGFV67rnn0KNHDwDArbfeih9++AHh4eFO217fvn3x9ttvO+WkwlS3uMcHR24iISEBJpPJOjk5OaojEdWYu7+6uPqs8RMnTkTz5s2duj2dToeJEyeiWbNmTt0OaV+tFldoaCgAIC8vz+byvLw867LQ0FDk5+fbLK+oqMCFCxes61zLYDDAaDTaDJGW6XQ61RGqLSYmxqVn9fjkk09cti3SplotrrZt2yI0NBTJycnWywoLC5Gamoro6GgAQHR0NAoKCpCenm5dZ9OmTbBYLIiKiqrNOERuSzTyuX+DwYDY2FiX/mfxD3/4A+655x6XbY80yN6jOYqKimTv3r2yd+9eASBvvfWW7N27V06fPi0ivx8OHxAQIN9++63s379fYmNjKz0c/vbbb5fU1FTZvn27tG/fnofDc+rVeHp6SkFBgb1PP5fr16+flJeXu3y7SUlJyn9GHNeMSw6H37x5c6UbHz16tIj8/weQQ0JCxGAwSO/evSUrK8vmNs6fPy9xcXHi5+cnRqNR4uPj+QFkTr0aDw8PTRTXlClTpKKiwuXbXbFihQQGBir/OXGcP44UF89VSKSAh4cHzp8/z8dxFWJjY7Fy5UrVMcjJHDlXoSaOKiSqa8xmM55++mnVMap0+fJlVFRUqI5BdB0WF5EiP/30k+oIVXrzzTeRlpamOgbRdVhcRESkKSwuIkXS09Px9ttvq45RqczMTMyePVt1DKJKsbiIFCkvL0dxcbHqGJVy52xELC4ihT7++GNkZWWpjmFDRPD8888DAEpKSpRkqKiogNlsVrJtcn8sLiKFTp06hc2bN6uOYWPfvn3YtWsXAGD48OFKjixcuHAh1q1b5/LtkjawuIgUmzx5MhYtWqQ6htXs2bOtXx1UXl6uJIPZbIbFYlGybXJ/LC4ixUpLS/Hf//5X+e+ULBYLFixYgDVr1lgvKy4udvnnzX7++WfMmDHDpdskbWFxEbmB1atX4+mnn8alS5eUZVi4cCGefPJJFBUVWS+zWCxISUnB4cOHXZbjm2++ue4bJIhs1PY5xlyB5yrk1NV58sknxWw2u/w59emnn0qjRo1umOu9995zSQ6z2Szt2rVT/nPguG4cOVchX3ERuZGPPvoITzzxhPV3TM4mIkhLS8N3331n80rrWs899xw2bNjg1CwFBQV47LHHcOrUKaduh+qA2v8/k/PxFRenrk98fLxLvk5k4cKF4uXlVa1M4eHhTs2yatUq5fud4/pxydeauAMWF6euj06nk6eeekouXLjglLcOCwoK5KOPPhKj0VjtTAaDQWbOnCkXLlyo9Tz5+fkSERGhfL9zXD8sLg6njo1er5e5c+dKWlparT1/du/eLcHBwaLT6ezOo9PpxNvbW9atW1crWQoKCmTZsmUSGRmpfF9z1AyLi8Opo9OhQwd54okn5OLFiw4/b2bOnCnx8fHSsWPHGucJDQ2VtWvX1uh5bLFYZNSoUcr3LUft1Lsvkmzfvj08PDyuW26xWHD06FEFyYicq1mzZhg9ejRGjx5tvSw8PByenp426504cQJlZWUAgKysLIwfPx7nzp2r1Q8UG41GhIWFYdmyZdDpdDd8Pl7r5MmTWLNmDRITE5Gbm8sPGtdzjnyRpKaL60Z3+PLly5g+fTrMZjM+/PBD5R/sJHKml19+GQEBATaXvf7668jLy3Npjtdeew0NGzaEt7c3xo8fD73+94OW9+3bh+TkZOt6c+bMwdmzZ12ajdwXi6sS27dvR0lJCV5++WXs2bPH+r9QInIODw8P/OlPf4JOpwPw+5kwjhw5ojgVuSsWVxXKysqwZ88eTJ8+HTt37sTFixednJKIiG7GkeKqNx9A9vb2Rs+ePbFhwwYkJiaqjkNERA6qN8V1tXHjxuHIkSOIi4uzvp1BRETaUC+Ly9PTEx07dsSSJUvw8MMPq45DRER2qJfFdYVOp8N7773H8iIi0pB6XVwAEBgYiIULFyIuLk51FCIiqoZ6X1wA0KBBAyxcuJCvvIiINIDF9X8MBgPef/99DB48WHUUIiKqAovrKoGBgejXrx98fHxURyEiohvwvPkq9cvf/vY3lJSUYPLkyaqjEBFRJfiKqxKDBw9GcHCw6hhERFQJFlclWrdujX/84x+qYxARUSVYXDfg4eFhPbs1ERG5D/7LfANjx45F7969VccgIqJrsLhuwNPTE2PGjIGXl5fqKEREdBUWVxUGDx7M4iIicjMsLiIi0hQW103wAA0iIvfCf5WrYDAYsGTJEtUxiIjoKiyum2jUqJHqCEREdBUWFxERaQqLi4iINIXFRUREmsLiIiIiTWFxVcFsNmPlypWqYxAR0VVYXFWoqKjAf/7zH9UxiIjoKiwuIiLSFBYXERFpCourCs888wwuX76sOgYREV2FxVWF06dPQ0RUxyAioquwuG5g/fr12Ldvn+oYRER0DRZXJUpLS5GcnIzc3FzVUYiI6BosrkpkZ2djzpw5qmMQEVElWFyVmDRpkuoIRER0A56qA7ibffv2IS0tTXUMqkM8PDzwwAMP2HwpqYhg7dq1qKioUJiMSJtYXFfJyMhAXFwcfv31V9VRqA6YPXs2jEYjPD098fjjj19XXAsXLkRZWRkuXryIadOm8QhWomrSiQafLYWFhfD394fJZILRaKyV2ywqKkKHDh14QAY5rHHjxmjTpg2++uor6PV6tGzZEh4eHje9nsViQU5ODkQEI0aMwPHjx3H+/HkXJCZSz6F/x0WDTCaTABCTyVRrt/npp5+KXq8XAByO3dOsWTNZv359rTwWN23aJK1atVJ+nzgcV4wj/47X++KyWCyyePFiCQgIUP4D5Ghv9Hq9TJ8+XXbu3FkLj+z/l5qaKjNnzuR/pjh1flhcdjp48KAsWLBAvLy8lP/wONobg8Egs2fPloqKilp6ZNuqqKiQt956S3x8fJTfVw7HWcPiskNaWppEREQo/6FxtDszZ86sxUf1jc2ZM0f5feVwnDUsrmooKiqSgQMHSsuWLZX/wDjanYSEBCktLXXCo/t65eXlMnv2bDEYDMrvN4dT2+PIv+N2fQA5MTERd955Jxo1aoTg4GAMHjwYWVlZNuuUlJRgwoQJaNKkCfz8/DBs2DDk5eXZrJOdnY0BAwbA19cXwcHBmDZtmtM/z2I2m/HFF1/goYcewurVq/Hzzz87dXtUdzVv3hy9evWCt7e3S7bn6emJ559/HgMHDnTJ9ojcnj0t17dvX1m4cKFkZmZKRkaGPPDAAxIWFibFxcXWdcaOHSutWrWS5ORk2b17t/Ts2VPuuusu6/KKigqJjIyUmJgY2bt3r6xdu1aCgoIkISGh2jmq+4rLYrHImTNnZOTIkfLwww+Lh4eH8v9dcLQ9BoNBNmzYYM/TptZs2bJFfH19le8DDqc2x+VvFebn5wsA2bp1q4iIFBQUiJeXlyxfvty6zuHDhwWApKSkiIjI2rVrRa/XS25urnWdpKQkMRqN1X7r5UpxnThxwnrZyZMnJSMjwzrvvvuuNG3aVBo3bqz8B8OpOxMZGSllZWU1edo4zGw2S7du3ZTvAw6nNseR4qrRmTNMJhOA3z94CQDp6ekoLy9HTEyMdZ2IiAiEhYUhJSUFPXv2REpKCjp37oyQkBDrOn379sW4ceNw8OBB3H777ddtp7S0FKWlpda/FxYWAgDGjh2LP/3pTwCAJUuW4ODBgzW5O0Q3NX/+fHh5eSnZtl6vR1JSEqKiopRsn8hdOFxcFosFkydPxt13343IyEgAQG5uLry9vREQEGCzbkhIiPWMFLm5uTaldWX5lWWVSUxMxKuvvnrd5Rs2bMCGDRscvQtEdomLi8Ntt92mNMMf/vAHxMfHY+HChUpzEKnk8NnhJ0yYgMzMTCxdurQ281QqISEBJpPJOjk5OU7fJtG1wsLC4O/vrzRDo0aN0Lp1a6UZiFRzqLgmTpyI1atXY/PmzWjZsqX18tDQUJSVlaGgoMBm/by8PISGhlrXufYowyt/v7LOtQwGA4xGo80QuVLz5s0xePBg1TEAAA888ADatGmjOgaRMnYVl4hg4sSJWLFiBTZt2oS2bdvaLO/evTu8vLyQnJxsvSwrKwvZ2dmIjo4GAERHR+PAgQPIz8+3rrNx40YYjUZ06tSpJveFyGkaN26Mnj17qo4BALjzzjsRHBysOgaROvYcyTFu3Djx9/eXLVu2yNmzZ61z6dIl6zpjx46VsLAw2bRpk+zevVuio6MlOjrauvzK4fB9+vSRjIwMWb9+vTRt2tShw+E5HFdNZGSkPU8Vp+vRo4fyfcLh1MY4/XD4G2144cKF1nUuX74s48ePl8DAQPH19ZUhQ4bI2bNnbW7n1KlT0r9/f/Hx8ZGgoCCZOnWqlJeXVzsHi4vj6mFxcTjOGUeKS9Pfx0XkKpGRkThw4IDqGFZRUVHYtWuX6hhENebI93E5fFQhERGRCiwuIiLSFBYXERFpCouLiIg0pUbnKiSqL44cOYJ//vOfeOmll1RHwZw5c7Bnzx7r3yMiIuDpefOn8okTJ3Dp0iVnRiNyCRYXUTVUVFSguLhYdQwAwMWLFxEXF4fmzZsD+P2UaNU5yvb9999HdnY2ACApKcl6smoireHh8ETV1KpVK6xatQpdu3ZVmuP06dNo3LgxGjVq5PBtpKamoqSkBNOnT8euXbtQUlJSiwmJqo+HwxM5UU5ODjZu3AjV/9dr3bp1jUoL+P1zYPfddx+Sk5OxY8cOtGvXrpbSETkfX3ER2aFhw4a4cOECvL29VUepVTt37sSmTZvw8ssvq45C9QxfcRE52aVLlzB27FjVMWrdXXfdhYSEBLz33nto3bo19Hr+00Dui49OIjuICHbt2oXMzEzVUWqdh4cHxo8fj5MnT2LUqFGq4xDdEIuLyE4HDx5EXFwcfv75Z9VRnEKn0+Gdd97BqFGjoNPpVMchug6Li8gBmZmZuO+++3DixAnVUZzC398fCxYswGOPPcbyIrfD4iJy0IkTJzB8+HAcPnxYdRSn8Pb2RlJSEv7617+qjkJkg8VFVAN79uzBwIEDMWrUKFy+fFl1nFpnMBgQFxeHBg0aqI5CZMXiIqqhEydO4LPPPkN8fDxWrFihOk6t69+/P+bPnw9fX1/VUYgA8HNcRLXKYDBgxIgR0Ol0mDt3LgICAlRHqjVt2rTB6dOnVcegOsaRz3GxuIicJDg4GHq9HgaDAStWrICXl5d1mcViwdChQ9GwYUMsX74cHTp0UJi0enbt2oWoqCjVMaiOcaS4eJJdIifJz8+3/rlbt26VrvPaa69porQA4JZbbkHv3r2RnJysOgrVc/wdF5EinTp10tQHfZs0aYK//OUv8PDwUB2F6jkWF5ECOp0OvXv3Rps2bVRHscuTTz6J+++/X3UMqudYXEQK6PV6zJw5U3UMu3l4ePADyaQci4uI7JKUlAQfHx/VMageY3ERKXD//fdr9qtRmjVrxrPHk1J89BEp8NRTT/FVC5GDWFxEZBe9Xo+IiAjVMageY3ERkV08PT3x5ptvqo5B9RiLi4iINIXFRUREmsLiIiIiTWFxERGRprC4iMguFoulTn7vGGkHi4uI7FJRUYEFCxaojkH1GIuLiIg0hcVFpMCiRYtQUlKiOgaRJrG4iBRYs2YNSktLVcdwyMSJE3Hp0iXVMageY3ERKSAiWL9+veoYDvn5558hIqpjUD3G4iJSwGKxYO7cuapj2G3dunXYu3ev6hhUz7G4iBQpLi7GL7/8ojqGXY4dO4bc3FzVMaieY3ERKZKZmYmPPvpIdYxqu3DhAtauXas6BhGLi0ilDz74AIcPH1Ydo1qys7M1+3s5qltYXEQKnTlzBuvWrVMd46b27NmDfv36qY5BBIDFRaRcQkIC/v3vf6uOUaUPP/wQeXl5qmMQAWBxESlXVlaGlStXwmQyqY5yHYvFgoULF2Lx4sWqoxBZsbiI3MC6deswduxYFBcXq45iY/HixXjiiSdw8eJF1VGIrDxVByCi3y1duhQeHh5YtGgRPD3VPjVFBIsXL8akSZNgsViUZiG6Fl9xEbmRzz//HKNGjcKFCxeU5li0aBHGjBnjlm9fEvEVF5EbEREsXboUwO9v06l45bV48WKMHz8eFRUVLt82UXXwFReRG/ryyy8RGRmJefPmuaxA8vPzsXDhQkycOJFnrie3xldcRG5IRJCVlYVnnnkGRUVFuPfee3HPPfc4bXtpaWkYPHiw5k5BRfWTTjR4mufCwkL4+/urjkHkMm3atEFUVBQ+/PBD+Pn5QafT1fg2LRYLysvL8cQTTyAtLQ1ZWVm1kJTIPiaTCUaj0a7rsLiINCQgIACPPvooRo0ahcDAQNxyyy1238bp06eRkZGB+Ph4AMBvv/1W2zGJqo3FRVSPdOrUCSNGjAAA9OzZE3369Kl0vbNnz+LDDz+0/n3lypVIT093SUaim2FxEdVToaGhaN26daXLLl68iMzMTBcnIqoeR4qLB2cQ1QG5ubn8niyqN3g4PBERaQqLi4iINIXFRUREmsLiIiIiTWFxERGRprC4iIhIU1hcRESkKXYVV1JSErp06QKj0Qij0Yjo6GisW7fOurykpAQTJkxAkyZN4Ofnh2HDhiEvL8/mNrKzszFgwAD4+voiODgY06ZN49cnEBFRtdlVXC1btsSsWbOQnp6O3bt3489//jNiY2Nx8OBBAMCUKVOwatUqLF++HFu3bsUvv/yCoUOHWq9vNpsxYMAAlJWVYefOnfjkk0+waNEiTJ8+vXbvFRER1V1SQ4GBgbJgwQIpKCgQLy8vWb58uXXZ4cOHBYCkpKSIiMjatWtFr9dLbm6udZ2kpCQxGo1SWlpa7W2aTCYBwOFwOByNj8lksrt3HP4dl9lsxtKlS3Hx4kVER0cjPT0d5eXliImJsa4TERGBsLAwpKSkAABSUlLQuXNnhISEWNfp27cvCgsLra/aKlNaWorCwkKbISKi+snu4jpw4AD8/PxgMBgwduxYrFixAp06dUJubi68vb0REBBgs35ISIj1HGq5ubk2pXVl+ZVlN5KYmAh/f3/rtGrVyt7YRERUR9hdXB07dkRGRgZSU1Mxbtw4jB49GocOHXJGNquEhASYTCbr5OTkOHV7RETkvuw+O7y3tzfCw8MBAN27d0daWhreeecdjBgxAmVlZSgoKLB51ZWXl4fQ0FAAv3/1wq5du2xu78pRh1fWqYzBYIDBYLA3KhER1UE1/hyXxWJBaWkpunfvDi8vLyQnJ1uXZWVlITs7G9HR0QCA6OhoHDhwAPn5+dZ1Nm7cCKPRiE6dOtU0ChER1Qf2HMnxwgsvyNatW+XkyZOyf/9+eeGFF0Sn08mGDRtERGTs2LESFhYmmzZtkt27d0t0dLRER0dbr19RUSGRkZHSp08fycjIkPXr10vTpk0lISHBriNKeFQhh8Ph1I1x5KhCu4rr8ccfl9atW4u3t7c0bdpUevfubS0tEZHLly/L+PHjJTAwUHx9fWXIkCFy9uxZm9s4deqU9O/fX3x8fCQoKEimTp0q5eXldoVmcXE4HE7dGEeKSyciAo0pLCyEv7+/6hhERFRDJpMJRqPRruvwXIVERKQpLC4iItIUFhcREWkKi4uIiDSFxUVERJrC4iIiIk1hcRERkaawuIiISFNYXEREpCksLiIi0hQWFxERaQqLi4iINIXFRUREmsLiIiIiTWFxERGRprC4iIhIU1hcRESkKSwuIiLSFBYXERFpCouLiIg0hcVFRESawuIiIiJNYXEREZGmsLiIiEhTWFxERKQpLC4iItIUFhcREWkKi4uIiDSFxUVERJrC4iIiIk1hcRERkaawuIiISFNYXEREpCksLiIi0hQWFxERaQqLi4iINIXFRUREmsLiIiIiTWFxERGRprC4iIhIU1hcRESkKSwuIiLSFBYXERFpCouLiIg0hcVFRESawuIiIiJNYXEREZGmsLiIiEhTWFxERKQpLC4iItIUFhcREWkKi4uIiDSFxUVERJrC4iIiIk1hcRERkaawuIiISFNYXEREpCksLiIi0hQWFxERaQqLi4iINIXFRUREmlKj4po1axZ0Oh0mT55svaykpAQTJkxAkyZN4Ofnh2HDhiEvL8/metnZ2RgwYAB8fX0RHByMadOmoaKioiZRiIionnC4uNLS0vDBBx+gS5cuNpdPmTIFq1atwvLly7F161b88ssvGDp0qHW52WzGgAEDUFZWhp07d+KTTz7BokWLMH36dMfvBRER1R/igKKiImnfvr1s3LhR7rvvPpk0aZKIiBQUFIiXl5csX77cuu7hw4cFgKSkpIiIyNq1a0Wv10tubq51naSkJDEajVJaWlqt7ZtMJgHA4XA4HI2PyWSyu4McesU1YcIEDBgwADExMTaXp6eno7y83ObyiIgIhIWFISUlBQCQkpKCzp07IyQkxLpO3759UVhYiIMHD1a6vdLSUhQWFtoMERHVT572XmHp0qXYs2cP0tLSrluWm5sLb29vBAQE2FweEhKC3Nxc6zpXl9aV5VeWVSYxMRGvvvqqvVGJiKgOsusVV05ODiZNmoQlS5agQYMGzsp0nYSEBJhMJuvk5OS4bNtERORe7HrFlZ6ejvz8fHTr1s16mdlsxg8//ID58+fju+++Q1lZGQoKCmxedeXl5SE0NBQAEBoail27dtnc7pWjDq+scy2DwQCDwWBPVCLljEYj7r///irXOXjwII4cOeKiRER1g13F1bt3bxw4cMDmsvj4eERERODvf/87WrVqBS8vLyQnJ2PYsGEAgKysLGRnZyM6OhoAEB0djX/961/Iz89HcHAwAGDjxo0wGo3o1KlTbdwnIqXuuOMO/O1vf0NgYKD1eXAj6enp2Lt3LwBg0aJF2LFjhysiEmmb3YdzXOPqowpFRMaOHSthYWGyadMm2b17t0RHR0t0dLR1eUVFhURGRkqfPn0kIyND1q9fL02bNpWEhIRqb5NHFXLcbcLDw2XWrFmSk5Mj58+fd+i5dOHCBdm2bZt07NhRfH19ld8nDscV48hRhbVeXJcvX5bx48dLYGCg+Pr6ypAhQ+Ts2bM21zl16pT0799ffHx8JCgoSKZOnSrl5eXV3iaLi+NOExsbKyUlJTV9Ktl4//33ZciQIcrvG4fj7HGkuHQiItCYwsJC+Pv7q45B9VzLli3x0Ucf4bbbbrO+7V2bzp8/j3HjxuGrr76CBp+mRNViMplgNBrtuo7dh8MTEdChQwesX78ebdu2ddo2mjRpgiVLlsDX1xepqak8iIPo//Aku0R2ioiIwJdffunU0rrCy8sLixYtwvLlyxEZGen07RFpAYuLyA4tW7bEmjVrcNttt7l0u5GRkejZsyd0Op1Lt0vkjlhcRNUUGRmJ77//Hu3atVOy/Q8++ADDhw9Xsm0id8LiIqqmgQMHomPHjsq2r9frkZSUhL/85S/KMhC5AxYXUTV06tTJLb56p3HjxujTpw8aNmyoOgqRMiwuomoYPXo0fHx8VMcAADz55JO49dZbVccgUobFRXQTvr6+iI+PVx3Dxty5c6HX8+lL9RMf+UQ38d5776Fp06aqY9jo3LkzevTooToGkRIsLqIq9OjRA3fffbfqGNfx8/PD1KlTVccgUoLFRVSF9u3bo3379qpjVMrPz8/uU+UQ1QUsLiKN6tevHz/XRfUSi4voBvz9/fHcc8+pjkFE12BxEd2At7c3unbtqjoGEV2DxUVERJrC4iIiIk1hcRERkaawuIiISFNYXEREpCksLqIbuHTpEr799lvVMYjoGiwuohu4ePEivvrqK9UxbqiiogJlZWWqYxC5HIuLSKO+/fZbfPbZZ6pjELkci4uoCqmpqUhNTVUdo1IiAhFRHYPI5VhcRFU4duwYtm3bBrPZrDqKjcLCQjz99NOqYxApweIiuolp06bh/PnzqmPY+Oabb5CXl6c6BpESLC6ianjxxRdVR7Aym82YN28e3yakeovFRVQNmzZtwsmTJ1XHAAC8/vrr2LNnj+oYRMqwuIiq4cSJE/jggw9Ux0BOTg7WrFkDi8WiOgqRMiwuomr6+OOP8f333yvb/m+//YZBgwZhx44dyjIQuQMWF1E1nTt3Dg8++CA2bNigZPtPPfUUMjIylGybyJ2wuIjsUFJSgvj4eJeWl4hg8+bNbvt5MiJXY3ER2emXX37BsGHDkJyc7JJt3XHHHYiNjUVOTo7Tt0ekBSwuIgcUFxfjL3/5CxITE3H06FGnbOPkyZN46KGHsGfPHhQVFTllG0RapBMNfhiksLAQ/v7+qmMQAQAiIyORnJyMgIAAeHt71+i2LBYLLl26hH/84x/YvHkzMjMzayklkXsymUwwGo12XYfFRVQLvLy88Mgjj2DYsGFo0aIFunXrZvdt7Nu3Dzt37sSkSZNQUVHBDxhTvcDiInID4eHhuP/++9G8eXO89NJLVa67evVqrF27FgCwefNmHDlyxBURidwGi4vIjXh5eaFFixZVrlNQUICCggLXBCJyQ44Ul6eTshDVe+Xl5Th16pTqGER1DouL6g0vL69qrSciqKiocHIaInIUi4vqNH9/f3Tu3BmBgYFYsmQJdDrdTa9z8OBBPPfccwB+P1tGVlaWs2MSkR34Oy6qk3r27IlBgwahVatW+Otf/+rw7WRmZmLlypVITExEcXFxLSYkIoAHZ1A95+3tDX9/fyxevBi33norWrZsWWu3nZmZCbPZjClTpmDz5s21drtE9R2Li+otT09PJCYmYurUqdV6O9BRJSUlGDt2LFJSUpx2xgyi+oTFRfXSoEGDEBcXhxEjRji1tK6WlpaGBx98EHl5eS7ZHlFdxeKiemfQoEFYsmQJ/Pz8XL7t8+fP45tvvsGzzz6LwsJCl2+fqC7g57ioXomNjcXnn38OX19fJdtv0qQJxowZA09PTzz11FMoKytTkoOovuHZ4UlzdDodBg0ahA8//FBZaV3t0Ucfxfz586v9OTEiqhkWF2nOwIED8d///hdNmzZVHQXA70X6xBNPYOrUqaqjENULLC7SlNjYWCxatAienu71LrdOp0NsbGytHoJPRJVjcZFmNGjQAA888AAaN26sOkqlevbsiXXr1iE4OFh1FKI6jcVFmqDX6/Haa6/hqaeeUh2lSpGRkXj33XdVxyCq01hcpAkNGjTAhAkTVMeolrvvvhu9evVSHYOozmJxkSYsXrzYLY4grI6WLVviz3/+M48yJHISFhe5vZ49e6Jr166qY9jlpZdeQpMmTVTHIKqTWFzk9u68807ccsstqmPYLSkpSXUEojqJxUVuzc/PD927d1cdwyHh4eGqIxDVSSwucmuhoaEYPXq06hgOadmyJR566CHVMYjqHBYXubW2bduqjuCwgIAA3HHHHapjENU5LC5yawsWLFAdgYjcDIuLyIm8vLyg1/NpRlSb+IwicqKnn34a9957r+oYRHWKXcX1yiuvQKfT2UxERIR1eUlJCSZMmIAmTZrAz88Pw4YNu+4bYrOzszFgwAD4+voiODgY06ZNQ0VFRe3cGyI34+Hh4bJvZSaqL+w+xfatt96K77///v9v4KqzdE+ZMgVr1qzB8uXL4e/vj4kTJ2Lo0KHYsWMHAMBsNmPAgAEIDQ3Fzp07cfbsWTz66KPw8vLC//zP/9TC3SEiojpP7DBjxgzp2rVrpcsKCgrEy8tLli9fbr3s8OHDAkBSUlJERGTt2rWi1+slNzfXuk5SUpIYjUYpLS2tdg6TySQAOPVgTp8+bc9D1C316tVL+X7kcNx1TCaT3c8pu3/H9dNPP6F58+Zo164dRo4ciezsbABAeno6ysvLERMTY103IiICYWFhSElJAQCkpKSgc+fOCAkJsa7Tt29fFBYW4uDBgzfcZmlpKQoLC22GiIjqJ7uKKyoqCosWLcL69euRlJSEkydP4o9//COKioqQm5sLb29vBAQE2FwnJCQEubm5AIDc3Fyb0rqy/MqyG0lMTIS/v791WrVqZU9sIiKqQ+z6HVf//v2tf+7SpQuioqLQunVrLFu2DD4+PrUe7oqEhAQ8++yz1r8XFhayvIiI6qkaHQ4fEBCADh064NixYwgNDUVZWRkKCgps1snLy0NoaCiA30/fc+1Rhlf+fmWdyhgMBhiNRpsh0oLFixdj9+7dqmMQ1Sk1Kq7i4mIcP34czZo1Q/fu3eHl5YXk5GTr8qysLGRnZyM6OhoAEB0djQMHDiA/P9+6zsaNG2E0GtGpU6eaRCFyS7m5uSgqKlIdg6husedIjqlTp8qWLVvk5MmTsmPHDomJiZGgoCDJz88XEZGxY8dKWFiYbNq0SXbv3i3R0dESHR1tvX5FRYVERkZKnz59JCMjQ9avXy9NmzaVhIQEu44o4VGF9WcmTpxo12PD3bz++uvK9yGH487jyFGFdhXXiBEjpFmzZuLt7S0tWrSQESNGyLFjx6zLL1++LOPHj5fAwEDx9fWVIUOGyNmzZ21u49SpU9K/f3/x8fGRoKAgmTp1qpSXl9sVmsVVfyY8PNyux4Y7OXLkiBiNRuX7kMNx53GkuHQiItCYwsJC+Pv7q45BLhAUFIQvv/wSf/7zn1VHsVtmZiY6d+6sOgaRWzOZTHYft2D3mTPcgQa7lhz066+/YtmyZZr8epApU6aojkDk9hz591yTr7hOnDihya9yJyIiWzk5OWjZsqVd19HkK67GjRsD+P2EvXzLsHJXPuuWk5PDjw9Ugvunatw/VeP+qVp19o+IoKioCM2bN7f79jVZXFe+38jf358Pmpvg596qxv1TNe6fqnH/VO1m+8fRFx78Pi4iItIUFhcREWmKJovLYDBgxowZMBgMqqO4Le6jqnH/VI37p2rcP1Vz9v7R5FGFRERUf2nyFRcREdVfLC4iItIUFhcREWkKi4uIiDRFk8X13nvvoU2bNmjQoAGioqKwa9cu1ZFc4ocffsCDDz6I5s2bQ6fT4ZtvvrFZLiKYPn06mjVrBh8fH8TExOCnn36yWefChQsYOXIkjEYjAgICMGbMGBQXF7vwXjhPYmIi7rzzTjRq1AjBwcEYPHgwsrKybNYpKSnBhAkT0KRJE/j5+WHYsGHXfblpdnY2BgwYAF9fXwQHB2PatGmoqKhw5V1xiqSkJHTp0sX6odDo6GisW7fOurw+75vKzJo1CzqdDpMnT7ZeVp/30SuvvAKdTmczERER1uUu3Te19h0OLrJ06VLx9vaWjz/+WA4ePChPPvmkBAQESF5enupoTrd27Vp58cUX5euvvxYAsmLFCpvls2bNEn9/f/nmm29k3759MmjQIGnbtq1cvnzZuk6/fv2ka9eu8uOPP8q2bdskPDxc4uLiXHxPnKNv376ycOFCyczMlIyMDHnggQckLCxMiouLreuMHTtWWrVqJcnJybJ7927p2bOn3HXXXdblV74zLiYmRvbu3Str166VoKAgu78zzh2tXLlS1qxZI0ePHpWsrCz5xz/+IV5eXpKZmSki9XvfXGvXrl3Spk0b6dKli0yaNMl6eX3eRzNmzJBbb71Vzp49a51z585Zl7ty32iuuHr06CETJkyw/t1sNkvz5s0lMTFRYSrXu7a4LBaLhIaGyhtvvGG9rKCgQAwGg3zxxRciInLo0CEBIGlpadZ11q1bJzqdTs6cOeOy7K6Sn58vAGTr1q0i8vv+8PLykuXLl1vXOXz4sACQlJQUEfn9Pwd6vV5yc3Ot6yQlJYnRaJTS0lLX3gEXCAwMlAULFnDfXKWoqEjat28vGzdulPvuu89aXPV9H82YMUO6du1a6TJX7xtNvVVYVlaG9PR0xMTEWC/T6/WIiYlBSkqKwmTqnTx5Erm5uTb7xt/fH1FRUdZ9k5KSgoCAAJuvCImJiYFer0dqaqrLMzubyWQC8P8nZU5PT0d5ebnNPoqIiEBYWJjNPurcuTNCQkKs6/Tt2xeFhYU4ePCgC9M7l9lsxtKlS3Hx4kVER0dz31xlwoQJGDBggM2+APj4AYCffvoJzZs3R7t27TBy5EhkZ2cDcP2+0dRJdn/99VeYzWabOw4AISEhOHLkiKJU7iE3NxcAKt03V5bl5uYiODjYZrmnpycaN25sXaeusFgsmDx5Mu6++25ERkYC+P3+e3t7IyAgwGbda/dRZfvwyjKtO3DgAKKjo1FSUgI/Pz+sWLECnTp1QkZGRr3fNwCwdOlS7NmzB2lpadctq++Pn6ioKCxatAgdO3bE2bNn8eqrr+KPf/wjMjMzXb5vNFVcRNU1YcIEZGZmYvv27aqjuJWOHTsiIyMDJpMJX331FUaPHo2tW7eqjuUWcnJyMGnSJGzcuBENGjRQHcft9O/f3/rnLl26ICoqCq1bt8ayZcvg4+Pj0iyaeqswKCgIHh4e1x2pkpeXh9DQUEWp3MOV+1/VvgkNDUV+fr7N8oqKCly4cKFO7b+JEydi9erV2Lx5s80X1IWGhqKsrAwFBQU261+7jyrbh1eWaZ23tzfCw8PRvXt3JCYmomvXrnjnnXe4b/D72135+fno1q0bPD094enpia1bt+Ldd9+Fp6cnQkJC6v0+ulpAQAA6dOiAY8eOufzxo6ni8vb2Rvfu3ZGcnGy9zGKxIDk5GdHR0QqTqde2bVuEhoba7JvCwkKkpqZa9010dDQKCgqQnp5uXWfTpk2wWCyIiopyeebaJiKYOHEiVqxYgU2bNqFt27Y2y7t37w4vLy+bfZSVlYXs7GybfXTgwAGbgt+4cSOMRiM6derkmjviQhaLBaWlpdw3AHr37o0DBw4gIyPDOnfccQdGjhxp/XN930dXKy4uxvHjx9GsWTPXP37sPrREsaVLl4rBYJBFixbJoUOH5KmnnpKAgACbI1XqqqKiItm7d6/s3btXAMhbb70le/fuldOnT4vI74fDBwQEyLfffiv79++X2NjYSg+Hv/322yU1NVW2b98u7du3rzOHw48bN078/f1ly5YtNofsXrp0ybrO2LFjJSwsTDZt2iS7d++W6OhoiY6Oti6/cshunz59JCMjQ9avXy9NmzatE4czv/DCC7J161Y5efKk7N+/X1544QXR6XSyYcMGEanf++ZGrj6qUKR+76OpU6fKli1b5OTJk7Jjxw6JiYmRoKAgyc/PFxHX7hvNFZeIyLx58yQsLEy8vb2lR48e8uOPP6qO5BKbN28WANfN6NGjReT3Q+JffvllCQkJEYPBIL1795asrCyb2zh//rzExcWJn5+fGI1GiY+Pl6KiIgX3pvZVtm8AyMKFC63rXL58WcaPHy+BgYHi6+srQ4YMkbNnz9rczqlTp6R///7i4+MjQUFBMnXqVCkvL3fxval9jz/+uLRu3Vq8vb2ladOm0rt3b2tpidTvfXMj1xZXfd5HI0aMkGbNmom3t7e0aNFCRowYIceOHbMud+W+4deaEBGRpmjqd1xEREQsLiIi0hQWFxERaQqLi4iINIXFRUREmsLiIiIiTWFxERGRprC4iIhIU1hcRESkKSwuIiLSFBYXERFpCouLiIg05X8Bvk+e0rUJbf8AAAAASUVORK5CYII=",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.imshow(output_image, cmap=\"gray\")\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 4. Example - Image with Stacked Circles\n",
        "\n",
        "And now a more complex example. In this case, we have a repeated feature that depends on another feature."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "execution": {
          "iopub.execute_input": "2022-06-29T20:32:45.107150Z",
          "iopub.status.busy": "2022-06-29T20:32:45.107150Z",
          "iopub.status.idle": "2022-06-29T20:32:45.286150Z",
          "shell.execute_reply": "2022-06-29T20:32:45.285650Z"
        }
      },
      "outputs": [],
      "source": [
        "circle1 = Circle(\n",
        "    position=lambda: np.random.rand(2) * 512,\n",
        "    radius=lambda: 20 + np.random.rand() * 20,\n",
        "    intensity=1,\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Add a circle with 2/3 the radius and 2 times the intensity of circle1.\n",
        "circle2 = Circle(\n",
        "    position=circle1.position,\n",
        "    radius=circle1.radius * 0.66,\n",
        "    intensity=circle1.intensity * 2,\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Add a circle with 1/3 the radius and 3 times the intensity of circle1.\n",
        "circle3 = Circle(\n",
        "    position=circle1.position,\n",
        "    radius=circle1.radius * 0.33,\n",
        "    intensity=circle1.intensity * 3,\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {},
      "outputs": [],
      "source": [
        "stacked_circles = circle1 >> circle2 >> circle3"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {},
      "outputs": [],
      "source": [
        "many_stacked_circles = stacked_circles ^ (lambda: np.random.randint(5, 10))\n",
        "    "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {},
      "outputs": [],
      "source": [
        "input_image = np.zeros((512, 512))\n",
        "\n",
        "output_image = many_stacked_circles.update()(input_image) "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.imshow(output_image, cmap=\"gray\")\n",
        "plt.show()"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "py_env_book",
      "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.15"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}