{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0baf5128-fc22-4536-a0c1-610d6b614b93",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "# System Overview\n",
    "\n",
    "[![Click and Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/metadriverse/metaurban/blob/main/documentation/source/new_env.ipynb)\n",
    "\n",
    "This section will walk through how we build new environments or simulations from scratch.\n",
    "Let's get familiar with the project first\n",
    "\n",
    "## Project Structure\n",
    "\n",
    "The project structure is as follows:\n",
    "- **documentation**:  It contains files building this documentation\n",
    "- **metaurban**:  the metaurban package, most content is in this directory\n",
    "\n",
    "The `metaurban` package has the following structure:\n",
    "- **assets**:  it is downloaded from github releases automatically, containing models, textures, and mini-batch real-world scenarios\n",
    "- **assets_pedestrain**:  it is downloaded from github releases automatically, containing 3D assets of pedestrians\n",
    "- **base_class**:  meta-classes for making other python classes, usually you don't need to modify it\n",
    "- **component**:  objects/vehicles/maps/lanes/building, almost all elements used for constructing scenario is here\n",
    "- **engine**:  it contains code regarding the simulation loop, top-down renderer, asset manager/loader, physics system, logger, skybox, shadow, and so on\n",
    "- **envs**:  a collection of gym-style environments\n",
    "- **examples**:  runnable scripts for making yourself familiar with MetaUrban\n",
    "- **manager**:  managers that defines how to create/forward scene are stored here\n",
    "- **obs**:  a collection of observations that define how to collect information from the simulator in each step\n",
    "- **policy**:  a collection of policies that define how an object should act in each step\n",
    "- **render_pipeline**:  it contains the deferred rendering pipeline, which is developed by [tobspr](https://github.com/tobspr/RenderPipeline)\n",
    "- **scenario**:  it defines the universal scenario format and a set of tools to read data from the format, like parsing object state\n",
    "- **shaders**:  .glsl shaders for making skybox, terrain, depth camera and so on\n",
    "- **tests**:  unitest are located here, which can be viewed as examples as well\n",
    "- **third_party**:  libraries developed by others\n",
    "- **utils**:  various tool functions\n",
    "- **constants.py**:  it defines constants and some properties used everywhere\n",
    "- **type.py**:  all objects have a type label, which is selected from here\n",
    "- **pull_asset**:  scripts to pull or update asset from the remote git release page"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7739d3dc-93c2-410d-8179-2112f14d36a2",
   "metadata": {},
   "source": [
    "## Start point-BaseEnv\n",
    "To start making your own environment, the first step is to have something runnable so you can build things on top of it.\n",
    "This can be done with `BaseEnv`, which is an empty environment with only a vehicle placed in this environment.\n",
    "So just make a new `your_env.py` file and put the following code into it.\n",
    "**Note: we usually use 3D renderer to do development as it shows more details, but using 2D visualizer is allowed as well. In this doc, we use 2D renderer for convinience.** \n",
    "If you have a screen with OpenGL support, you can completely remove the `env.render` and `env.top_down_renderer.generate_gif`. If OpenGL is not supported on your machine but a screen is still available, just turn off the `screen_record` and set `window=True` for top_down_renderer and remove `env.top_down_renderer.generate_gif`. Otherwise, just keep everying unchanged. Without a screen, the only way to visualize the environment is through generating GIFs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d7e05617-1c6d-41ee-8277-de6393fc0b11",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/gif": "R0lGODlhyADIAIEAAObm5gKeczw8PAAAACH/C05FVFNDQVBFMi4wAwEAAAAh+QQAPAAAACwAAAAAyADIAEAI/wABCBxIsKDBgwgTKlzIsKHDhxAjSpxIsaLFixgzatzIsaPHjyBDihxJsqTJkyhTqlzJsqXLlzBjypxJs6bNmzhz6tzJs6fPn0CDCh1KtKhRgQIEBFjKtKnTp0uTHp3qMSnUq1elUt3KtavXr2DDih1LtqzZs2jTql3Ltq3bt3Djyp1Lt67du3jz6t3Lt6/fv4ADCx5MuLDhw4gTK55oFatjploXS55MubLly5gza97MubPnz6BDix5NurTp06hTq17NurXr17Bjy55Nu7bt27hz697Nu7fv38CDR0xKvLjx48iFI1X6+HHk4I2bY30OHLn169SVa9/Ovbv37+DDi5gfT768+fPo06tfz769+/fw48ufT7++/fv48+vfz7+///8ABijggAQWaOCBCCao4IIMNujggxBGKOGEFFZo4YUYZqjhhhzCh92Hx2kXnXRQZefbiCQ6ZWJvKKYImQAiMueiijAqB+KNK3ao44489ujjj0AGKeSQRBZp5JFIJqnkkkw26eSTUEYp5ZRUVmnllVhmqeWWXPYXEAA7",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from metaurban.envs.base_env import BaseEnv\n",
    "from metaurban.obs.observation_base import DummyObservation\n",
    "import logging\n",
    "\n",
    "class MyEnv(BaseEnv):\n",
    "\n",
    "    def reward_function(self, agent):\n",
    "        return 0, {}\n",
    "\n",
    "    def cost_function(self, agent):\n",
    "        return 0, {}\n",
    "\n",
    "    def done_function(self, agent):\n",
    "        return False, {}\n",
    "    \n",
    "    def get_single_observation(self):\n",
    "        return DummyObservation()\n",
    "        \n",
    "\n",
    "if __name__==\"__main__\":\n",
    "    # create env\n",
    "    env=MyEnv(dict(use_render=False, # if you have a screen and OpenGL suppor, you can set use_render=True to use 3D rendering  \n",
    "                   manual_control=True, # we usually manually control the car to test environment\n",
    "                   log_level=logging.CRITICAL)) # suppress logging message\n",
    "    env.reset()\n",
    "    for i in range(20):\n",
    "        \n",
    "        # step\n",
    "        obs, reward, termination, truncate, info = env.step(env.action_space.sample())\n",
    "        \n",
    "        # you can set window=True and remove generate_gif() if you have a screen. \n",
    "        # Or just use 3D rendering and remove all stuff related to env.render()  \n",
    "        frame=env.render(mode=\"topdown\", \n",
    "                         window=False, # turn me on, if you have screen\n",
    "                         screen_record=True, # turn me off, if a window can be poped up\n",
    "                         screen_size=(200, 200))\n",
    "    env.top_down_renderer.generate_gif()\n",
    "    env.close()\n",
    "\n",
    "from IPython.display import Image\n",
    "Image(open(\"demo.gif\", 'rb').read())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "511c57de-38a7-4a85-9fd0-09e997a1948e",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "As shown in the figure above, this environment contains nothing. We will make it complete gradually.\n",
    "Firstly, let's add a map to the environment to make it a bit interesting.\n",
    "**Also, when we develop a new environment, developing map and map management module is the first step we do. This is because map is the most important component associated with a lot of things like observation and navigation. Thus, the map has to be created in a scene firstly and the map management module `map_manager` should have the highest priority.**\n",
    "\n",
    "## MapManager\n",
    "Compared to the last code cell, we add a map manager to generate different maps for each seed. Concretely, there are three maps and we choose from the three maps according to the global seed by `map_id = global_seed % 3`. New content added upon the last code cell are marked between two `======`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "5bc70887-1206-43a2-ad29-645175d03a0c",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Load map with shape: X\n",
      "Load map with shape: T\n",
      "Load map with shape: O\n",
      "Load map with shape: X\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABkAAAAGQCAIAAAB59ztRAAAgAElEQVR4AezBjWlrZ9uE0dm9qIdAwD1MCUPq+WoIdwnTgyGQHtTL84UDB3bIu23551iSda21rbUEABdLMjMCAADArUoyMwKAz5ZkZnQN21pLAHCZJDMjAAAA3KokM6OdtpJsCwA+IMnM6Eq2tZYA4DJJZkYAAAC4PUkkzYx+aivJtgDgw5LMjK5kW2sJAC6TZGYEAACAG5NkZvRTW0m2BQCfJMnM6Eq2tZYA4DJJZkYAAAC4JUlmRj+0lWRbAPCpksyMrmRbawkALpNkZgQAAIDbkETSzEhqK8m2AOAXSDIzupJtrSUAuEySmREAAABuQJKZEQB8iSQzoyvZ1loCgMskmRkBAADg2pL4BwHAl0gyM7qSba0lALhAkpkRAAAAriqJJP8gAPgSSWZG17OttQQAF0gyMwIAAMD1JPEPAoAvlGRmdD3bWksAcIEkMyMAAABcSZKZEQB8uSQzo+vZ1loCgAskmRkBAADgyyWRNDP6mLaSbAsA3iLJzOh6trWWAOACSWZGAAAA+FpJZkYf0FY/2BYAvF2SmdH1bGstAcAFksyMAAAA8FWSSJoZvVdbSbYFAB+QZGZ0PdtaSwDwmiQzIwAAAHyJJJJmRu/VVpJtAcDHJJkZXdW21hIAvCbJzAgAAAC/XpKZEQDchiQzo6va1loCgNckmRkBAADgV0oiaWYEADcjyczoqra1lgDgNUlmRgAAAPhlksyM3qWtJNsCgM+WZGZ0VdtaSwDwmiQzIwAAAPwCSSTNjN6urSTbAoBfI8nM6Kq2tZYA4EVJZkYAAAD4bEkkzYzerq0k2wKAXybJzOjatrWWAOBFSWZGAAAA+FRJZkZv11aSbQHAL5ZkZnRt21pLAPCiJDMjAAAAfJIkkmZGb9fWtj6srW0BwIuSzIyubVtrCQBelGRmBAAAgM+QZGb0dm0l2dbHtJVkWwDwmiQzo2vb1loCgGNJZkYAAAD4DElmRm/UVpJtAcAXSjIzugHbWksAcCzJzAgAAAAfk0TSzOgt2kqyrfdqa1sA8HZJZkY3YFtrCQCOJZkZAQAA4AOSzIzeqK1tvVdbSbYFAO+SZGZ0A7a1lgDgWJKZEQAAAN4ryczoC7WVZFsA8AFJZkY3YFtrCQAOJJkZAQAA4F2SSJoZfZW2kmwLAD4myczoNmxrLQHAgSQzIwAAALxdkpnRW7S1rfdqa1sA8BmSzIxuw7bWEgAcSDIzAgAAwBslmRldrK0k2wKA25BkZnQbtrWWAOBAkpkRAAAA3iLJzOhibW3rXdpKsi0A+FRJZka3YVtrCQD+lyQzIwAAAFwsiaSZ0cXa2tbbtZVkWwDw2ZLMjG7GttYSAPwvSWZGAAAAuEySmdHF2kqyrTdqK8m2PqIn+SwA+F+SzIxuxrbWEgD8L0lmRgAAALhAkpnRxdra1hu1lWRbH9GT/uGzAOBAkpnRzdjWWgKA/0gyMwIAAMAFksyMfrG2tvURPekfPgsAjiWZGd2Sba0lAPiPJDMjAAAAvCbJzOjG9aR/+CwAeE2SmdEt2dZaAoD/SDIzAgAAwLEkkmZGt6wn/cNnAcBlksyMbsm21hIA/EeSmREAAAAOJJkZXaytbb1FW9t6t570D58FAG+RZGZ0S7a1lgDg35LMjAAAAHAgyczoYm1t6y3a2tb79KR/+CwAeKMkM6Mbs621BAD/lmRmBAAAgP8lyczoYm1t6y3a2tb79CSfBQDvkmRmdGO2tZYA4N+SzIwAAADwH0lmRhdra1sXayvJtt6hJ/3DZwHAeyWZGd2Yba0lANhJMjMCAADAfySZGV2srW1drK1tvU9P8lkA8AFJZka3Z1trCQB2ksyMAAAA8G9JZkYXa2tbF2trW+/Qk/7hswDgY5LMjG7PttYSAPyUZGYEAACAf0syM7pYW9u6WFvbeoee5LMA4MOSzIxu0rbWEgD8lGRmBAAAgJ0kM6Nb05P+4bMA4DMkmRndpG2tJQD4IcnMCAAAADtJZka3pif5LAD4JElmRrdqW2sJAH5IMjMCAADAT0lmRr9GW9t6q570D58FAJ8nyczoVm1rLQGAlGRmBAAAgJ+SzIwu09a2LtbWtt6qJ/ksAPhUSWZGN2xbawkApCQzIwAAAPyQZGZ0mba2dbG2tvUmPekfPgsAPluSmdEN29ZaAvDwksyMAAAA8EOSmdFl2trWZdpKsq036Uk+CwB+gSQzo9u2rbUE4OElmRkBAABASjIzukxb27pMW9t6k570D58FAL9GkpnRbdvWWgLw2JLMjAAAACAlmRldpq1tXaatbb1JT/JZAPDLJJkZ3bxtrSUAjy3JzAgAAODhJZkZXaatbV2mrW1drif9w2cBwK+UZGZ087a1lgA8sCQzIwAAgIeXZGZ0mba29Yv0JJ8FAL9YkpnRPdjWWgLwwJLMjAAAAB5bkpnR1fWkf/gsAPj1ksyM7sG21hKAR5VkZgQAAPDYksyMrq4n+SwA+BJJZkZ3YltrCcCjSjIzAgAAeGxJZkafra1tXagn+SwA+CpJZkZ3YltrCcBDSjIzAgAAeGxJZkYXaGtbl2lrWxfqST4LAL5KkpnR/djWWgLwkJLMjAAAAB5YkpnRBdra1mXa2taFepLPAoAvlGRmdD+2tZYAPJ4kMyMAAIAHlmRmdIG2tnWBtpJs60I9yWcBwBdKMjO6K9taSwAeT5KZEQAAwKNKMjO6QFvbukBb27pQT/qHzwKAr5VkZnRXtrWWADyYJDMjAACAR5VkZnSBtrZ1gba2daGe5LMA4MslmRndm22tJQAPJsnMCAAA4CElmRldoK1tXaCtbV2oJ/ksALiGJDOje7OttQTgkSSZGQEAADyqJDOj17S1rU/Xk3wWAFxDkpnRHdrWWgLwSJLMjAAAAB5SkpnRtfQknwUAV5JkZnSHtrWWADyMJDMjAACAh5RkZnQtPclnAcCVJJkZ3adtrSUAjyHJzAgAAOBRJZkZfZK2tnWhnuSzAOBKksyM7ta21hKAx5BkZgQAAPCQksyMPklb27pQT/JZAHA9SWZGd2tbawnAA0gyMwIAAHhISWZGr2lrWxdoa1uX6Ek+CwCuJ8nM6J5tay0B+O6SzIwAAAAeUpKZ0Wva2tYF2trWJXqSzwKA60kyM7pz21pLAL67JDMjAACAh5RkZvSatrb1mra2dYme5LMA4KqSzIzu3LbWEoBvLcnMCAAA4CElmRm9pq1tvaatbV2oJ/ksALieJDOj+7ettQTg+0oyMwIAAHhISWZGr2lrWxdoa1uX6Ek+CwCuJ8nM6FvY1loC8H0lmRkBAAA8pCQzoxe1ta0LtLWtS/QknwUAV5VkZvQtbGstAfimksyMAAAAHlKSmdFr2trWJ+pJPgsArirJzOi72NZaAvAdJZkZAQAAPKQkM6PXtLWtT9STfBYAXFWSmdE3sq21BOA7SjIzAgAAeEhJZkZfrCf5LAC4tiQzo29kW2sJwLeTZGYEAADwkJLMjD5DW9u6RE/yWQBwbUlmRt/LttYSgO8lycwIAADgUSWZGX1YW9u6RE/yWQBwbUlmRt/OttYSgG8kycwIAADgUSWZGX2GtrZ1iZ7kswDgqpLMjL6jba0lAN9IkpkRAADAQ0oyM3pRW9t6TVvbukRP8lkAcG1JZkbf0bbWEoDvIsnMCAAA4FElmRkda2tbr2lrW5foST4LAK4tyczom9rWWgLwLSSZGQEAADyqJDOjF7W1rRe1ta1L9CSfBQDXlmRm9H1tay0BuH9JZkYAAACPKsnM6EVtbes1bW3rVT3JZwHAtSWZGX1r21pLAO5ckpkRAADAA0syM3pRW9t6UVvbelVP8lkAcG1JZkbf3bbWEoB7lmRmBAAA8MCSzIxe1Na2PktP8lkAcFVJZkYPYFtrCcA9SzIzAgAAeGBJZkYvamtbn6In+SwAuLYkM6MHsK21BOBuJZkZAQAAPLAkM6MXtbWtT9GTfBYAXFuSmdFj2NZaAnCfksyMAAAAHlhb2/oyPclnAcC1JZkZPYxtrSUAdyjJzAgAAOCBtbWtz9DWtl7Vk3wWAFxVkpnRI9nWWgJwb5LMjAAAAB5bW9v6sLa29aqe5LMA4KqSzIwezLbWEoC7kmRmBAAA8Nja2tZnaGtbL+tJPgsArirJzOjxbGstAbgfSWZGAAAAjy2Jf9CHtbWtV/UknwUA15NkZvSQtrWWANyJJDMjAACAh9fWtl7U1rZe09a2XtaTfBYAXE+SmdGj2tZaAnAPksyMAAAAHl5b23pNW9t6UVvbellP8lkAcD1JZkYPbFtrCcDNSzIzAgAAeHhJ/INe1Na2XtTWtl7Vk3wWAFxJkpnRY9vWWgJw25LMjAAAACC1ta3XtLWtF7W1rZf1JJ8FAFeSZGb08La1lgDcsCQzIwAAAEhJZkavaWtbL2prWy/rST4LAK4kycwI0rbWEoBblWRmBAAAACnJzOgCbW3r43qSzwKAa0gyM8IP21pLAG5SkpkRAAAAfkgyM3pNW9t6UVvbellP8lkAcA1JZkb4aVtrCcDtSTIzAgAAwA9JZkYXaGtbx9ra1st6ks8CgGtIMjPCzrbWEoBbkkTSzAgAAAA/JJkZXaCtbb2orW29rCf5LAD4WkkkzYzwb9taSwBuRpKZEQAAAH5KMjOS2trWx7S1rZf1JJ8FAF8rycwI/8u21hKA25BkZgQAAICfksyMfmhrWx/T1rZe1pN8FgB8oSQzIxzY1loCcAOSzIwAAADwU5KZ0Q9tbetj2trWy3qSzwKAL5RkZoRj21pLAK4tycwIAAAAPyWZGf3U1rY+pq1tvaAn+SwA+EJJZkZ40bbWEoDrSSJpZgQAAICdJDOjH9ra1rG2tvWitrb1sp7kswDgSySRNDPCa7a1lgBcSZKZEQAAAP4tyczop7a2daytbX1QT/JZAPAlksyMcJltrSUA15BkZgQAAIB/SzIz+qmtbR1ra1sf15N8FgD8eklmRrjYttYSgC+XZGYEAACAf0syM9ppa1vH2trWB/UknwUAv16SmRHeYltrCcAXSiJpZgQAAIB/SzIz2mlrWy9qa1sf1JN8FgD8SkkkzYzwRttaSwC+SpKZEQAAAP4jyczojdra1rG2tvWynuSzAOBXSjIzwrtsay0B+BJJZkYAAAD4jyQzo7dra1vH2trWy3qSzwKAXybJzAjvta21BODXSzIzAgAAwL8lkTQzeru2tnWsrW29rCf5LAD4ZZLMjPAB21pLAH6xJDMjAAAA/FuSmdF7tbWtY21t62U9yWcBwK+RZGaEj9nWWgLwyySRNDMCAADAvyWZGf1KbW3rBT3JZwHAL5BE0swIH7attQTg10gyMwIAAMB/JJkZHWtrWx/Q1rZe1pN8FgB8tiQzI3ySba0lAL9AkpkRAAAA/iPJzOhFbW3rA9ra1gt6ks8CgM+WZGaEz7OttQTgUyWRNDMCAADAvyWRNDN6UVvb+oC2tvWynuSzAODzJJE0M8Kn2tZaAvBJkkiaGQEAAOA/ksyMLtDWtj6grW29oCf5LAD4JEkkzYzwC2xrLQH4sCSSZkYAAAD4X5LMjC7T1raOtbWtj+hJPgsAPiyJpJkRfpltrSUAH5BE0swIAAAA/0sSSTOjy7S1rRe1ta1360k+CwA+JomkmRF+sW2tJQDvkkTSzAgAAAAHksyM3qKtbR1ra1sf0ZN8FgC8VxJJMyN8iW2tJQBvlETSzAgAAADHksyM3qitbR1ra1sf0ZN8FgC8XRJJMyN8oW2tJQAXSyJpZgQAAIBjSSTNjN6orW29qK1tvVtP8lkA8EZJJM2M8OW2tZYAXCCJpJkRAAAAXpRkZvQubW3rWFvbOtbWtl7Qk3wWAFwsiaSZEa5kW2sJwIuSSJoZAQAA4DVJZka/TFvbOtbWtl7Qk3wWAFwgiaSZEa5qW2sJwIEkkmZGAAAAeE0SSTOjX6atbR1ra1sv6Ek+CwBek0TSzAg3YFtrCcB/JJE0MwIAAMBrkkiaGf1ibW3rWFvbekFP8lkAcCyJpJkRbsa21hKAnSSSZkYAAAB4TRJJM6Pb0Na2jvQknwUAB5JImhnhxmxrLQGQkuiHmREAAABek0TSzOhmtLWtF/QknwUA/5ZEP8yMcJO2tZaAB5ZEP8yMAAAAcIEkkmZGn6qtbX1AW9t6QU/yWQDwQxL9MDPCbdvWWgIeTxL9MDMCAADAZZJImhn9Am1t673a2tYLepLPAvDwkuiHmRHuxLbWEvBIkkiaGQEAAOBiSSTNjH6Ztrb1Xm1t6wU9yWcBeGBJJM2McG+2tZaAB5BEP8yMAAAAcJkk+mFm9Cu1ta1jbW3rI3qSzwLweJLoh5kR7tO21hLwfSXRDzMjAAAAXCaJfpgZfYm2tnWsrW19RE/yWQAeRhL9MDPCndvWWgK+lyT6aWYEAACAyyTRDzOjr9XWto61ta1360k+C8B3l0Q/zYzwXWxrLQHfQhL9MDMCAADAWySRNDO6kra2daCtbX1ET/JZAL6pJPphZoTvaFtrCbhbSfTTzAgAAABvkUQ/zIyup61tHWtrWx/Rk3wWgG8kiX6aGeFb29ZaAu5HEu3MjAAAAHCxJNqZGd2AtrZ1rK1tHWtrW0d6ks8CcOeSaGdmhIexrbUE3KQk+o+ZEQAAAC6QRP8xM7o9bW3rWFvbOtbWto70JJ8F4H4k0X/MjPCotrWWgGtIohfNjAAAAHAsiY7NjL6Ftrb1ora2daQn+SwANyOJXjQzAna2tZZuTxLhzs2Mfkii/2VmBNy/JAKAf5sZ3Z4kwrczM3oAbW3rWFvbekFP8lm4E0mEOzcz+iGJ/peZEfAW21pLAAAAAHC32trWkZ7kswAA92xbawkAAAAA7lZb2zrSk3wWAOCebWstAQAAAMDdamtbR3qSzwIA3LNtrSUAAAAAuJK2tvVebW3rBT3JZwEA7tm21hIAAAAAXElb23qvtrb1gp7kswAA92xbawkAAAAArqStbR1oa1vv1pN8FgDgzm1rLQEAAADAlbS1rQNtbevdepLPAgDcuW2tJQAAAAC4kra2daCtbb1bT/JZAIA7t621BAAAAADX0Na2jrW1rXfrST4LAHDntrWWAAAAAOAa2trWsba29W49yWcBAO7cttbSPWirY7a101bHbGunrY7Z1k5bHbOtnbY6Zls7bXXMtnba6pht7bTVMdvaaatjtrXTVsdsC3hIbXXMtnba6pht7bTVMdvaaatjtrXTVsdsa6etjtnWTlsds62dtjpmWzttdcy2dtrqmG0BD6mtjtnWTlsds62dtjpmWzttdcy2dtrqmG3ttNUx29ppq2O2tdNWx2xrp62O2dZOWx2zrW+nrW0daGtbx9ra1gt6ks/CnWurY7a101bHbGunrY7Z1k5bHbOtnbY6Zls7bXXMtnba6pht7bTVMdvaaatjtrXTVsdsC/hU21pLAAAAAHANbW3rQFvbOtbWtl7Qk3wWAODObWstAQAAAMA1tLWtA21t61hb2zrSk3wWAOD+bWstAQAAAMDtaWtbx9ra1pGe5LMAAPdvW2sJAAAAAO5QW9s60pN8FgDg/m1rLQEAAADAvWlrWy/oST4LAHD/trWWAAAAAODetLWtF/QknwUAuH/bWksAAAAAcG/a2tYLepLPAgDcv22tJQAAAAD4cm1t673a2tYLepLPAgDcv22tJQAAAAD4cm1t61hb2zrQ1rZe0JN8FgDg/m1rLd2DtjpmWzttdcy2dtrqmG3ttNUx29ppq2O2tdNWx2xrp62O2dZOWx2zrZ22OmZbO211zLaAh9RWx2xrp62O2dZOWx2zrZ22OmZbO211zLZ22uqYbe201THb2mmrY7a101bHbGunrd7Otnba6pht7bTVMdvaaatjtrXTVsdsa6etjtnWTlsds62dtjpmWzttdcy2dtrqmG3ttNUx29ppq2O2tdNWx2xrp63+zbbuQVsds62dtjpmWzttdcy2dtrqmG3ttNUx29ppq2O2tdNWx2xrp62O2dZOWx2zrZ22OmZb30tb2zrW1rberSf5LNy/tjpmWzttdcy2dtrqmG3ttNUx29ppq2O2tdNWx2xrp62O2dZOWx2zrZ22OmZbO211zLaAT7WttQQAAAAAX66tbR1ra1vv1pN8FgDg/m1rLQEAAADAl2trW8fa2ta79SSfBQC4f9taSwAAAADw5dra1rG2tvU+PclnAQC+hW2tJQAAAAD4cm1t60Bb2zrW1raO9CSfBQD4Fra1lgAAAADgy7W1rQNtbetYW9s60pN8FgDgW9jWWgIAAACAL9fWtg60ta1jbW3rSE/yWQCAb2FbawkAAAAAvlxb2zrQ1raOtbWtIz3JZwEAvoVtrSUAAAAA+HJtbetAW9s61ta2jvQknwUA+Ba2tZYAAAAA4N60ta0jPclnAQC+hW2tJQAAAAC4N21t60hP8lkAgG9hW2vpBvUk3DufBTyCnoR7Vv2fDtjWTlsds62dtjpmWzttdcy2dtrqmG3ttNUx29ppq2O2tdNWx2xrp62O2dZOWx2zrZ22OmZbO211zLZ22uqYbe201b/Z1g3qSbh3Pgs7bW3rSE/yWbhHPQn3zmcBn2pbawkAAAAA7k1b2zrSk3wWAOBb2NZauh9PT096i+fnZwHANTw9Pektnp+fBQDX8PT0pLd4fn4WcBva2taRnuSz8I08PT3pLZ6fnwXgu9jWWrofT09Peovn52cBwDU8PT3pLZ6fnwUA1/D09KS3eH5+FvBJ2trWgba29W49yWfhG3l6etJbPD8/C8B3sa21dD+enp4k/fXHb3rN73/+Len5+VkAcA1PT0+S/vrjN73m9z//lvT8/CwAuIanpydJf/3xm17z+59/S3p+fhbwSdra1oG2tvVuPcln4Rt5enqS9Ncfv+k1v//5t6Tn52cB+C62tZbux9PTk6S//vhNr/n9z78lPT8/CwCu4enpSdJff/ym1/z+59+Snp+fBQDX8PT0JOmvP37Ta37/829Jz8/PAj5JW9s60Na23q0n+Sx8I09PT5L++uM3veb3P/+W9Pz8LADfxbbW0v14enqS9Ncfv+k1v//5t6Tn52cBwDU8PT1J+uuP3/Sa3//8W9Lz87MA4Bqenp4k/fXHb3rN73/+Len5+VnAJ2lrWwfa2ta79SSfhW/k6elJ0l9//KbX/P7n35Ken58F4LvY1lq6H09PT5L++uM3veb3P/+W9Pz8LAC4hqenJ0l//fGbXvP7n39Len5+FgBcw9PTk6S//vhNr/n9z78lPT8/C/gkbW3rQFvb+oie5LPwXTw9PUn664/f9Jrf//xb0vPzswB8F9taS/fj6elJb/H8/CwAuIanpye9xfPzswDgGp6envQWz8/PAj5JW9s61ta2DrS1rRf0JJ+F7+Lp6Ulv8fz8LADfxbbW0v14enrSxZ6fnwUAV/L09KSLPT8/CwCu5OnpSRd7fn4W8Hna2taxtrZ1oK1tvaAn+Sx8F09PT7rY8/OzAHwj21pLt6etjtnWTlsds62dtjpmWzttdcy2dtrqmG3ttNUx29ppq2O2tdNWx2xrp62O2dZOWx2zLeAhtdUx29ppq2O2tdNWx2xrp62O2dZOWx2zrZ22OmZbO211zLZ22uqYbe201THb2mmrY7a101bHbGunrY7Z1k5bHbOtnbY6Zls7bXXMtnba6pht7bTVMdvaaatjtrXTVsdsa6etjtnWTlsds62dtjpmWzttdcy2dtpqx7ZuT1sds62dtjpmWzttdcy2dtrqmG3ttNUx29ppq2O2tdNWx2xrp62O2dZOWx2zrZ22OmZb311b2zrW1rYOtLWtF/Qkn4V701bHbGunrY7Z1k5bHbOtnbY6Zls7bXXMtnba6pht7bTVMdvaaatjtrXTVsdsa6etjtkW8Ittay0BAAAAwJdra1vH2trWgba29YKe5LMAAPdvW2sJAAAAAL5cW9t6r7a29YKe5LMAAPdvW2sJAAAAAO5QW9s60pN8FgDg/m1rLQEAAADAHWprW0d6ks8CANy/ba0lAAAAALhDbW3rSE/yWQCA+7ettQQAAAAAd6itbR3pST4LAHD/trWWAAAAAOD2tLWtY21t6wU9yWcBAO7cttYSAAAAAFxDW9s60Na2PqIn+SwAwJ3b1loCAAAAgGtoa1sH2trWR/QknwUAuHPbWksAAAAAcA1tbetAW9v6iJ7kswAAd25ba+n2tNUx29ppq2O2tdNWx2xrp62O2dZOWx2zrZ22OmZbO211zLZ22uqYbe201THb2mmrY7YFPKS2OmZbO211zLZ22uqYbe201THb2mmrY7a101bHbGunrY7Z1k5bHbOtnbY6Zls7bXXMtoCH1FbHbGunrY7Z1k5bHbOtnbY6Zls7bXXMtnba6pht7bTVMdvaaatjtrXTVsdsa6etjtnWA2hrWwfa2tZH9CSfhbvSVsdsa6etjtnWTlsds62dtjpmWzttdcy2dtrqmG3ttNUx29ppq2O2tdNWx2xrp62O2Rbwi21rLQEAAADANbS1rWNtbetYW9s60pN8FgDgzm1rLQEAAADANbS1rWNtbetYW9s60pN8FgDgzm1rLQEAAADAlbS1rQNtbetYW9s60pN8FgDgzm1rLQEAAADAlbS1rQNtbetYW9t6QU/yWQCAe7attQQAAAAAV9LWtg60ta1jbW3rBT3JZwEA7tm21hIAAAAAXElb2/qAtrZ1pCf5LADAPdvWWgIAAACAK2lrWx/Q1raO9CSfBQC4Z9taSwAAAABwt9ra1pGe5LMAAPdsW2sJAAAAAO5WW9t6QU/yWQCAu7WttXR7kgjf0cwI+F6SCN/RzAj4XpII39HM6AG0ta0DbW3rBT3JZ+FOJBG+o5kR8F7bWkvAV0miF82MAOAGJNGxmREA3IYkOjAz+i7a2ta79SSfBeCqkuhFMyPgwLbWEnAzkug/ZkYAcEuS6H+ZGQHAzUiinZnR3WprWx/Rk3wWgBuWRP8xMwKkba0l4LYl0SSgWlUAAB+qSURBVL/NjADg9iTRv82MAOA2JNHOzOhmtLWtY21t6yN6ks8CcG+S6N9mRng821pLwL1Jop2ZEQDcpCTamRkBwG1Iop9mRlfV1raOtbWtj+hJPgvA/UuinZkRHsC21hJw55Lop5kRANyqJPppZgQAtyGJfpgZXUNb23pRW9t6t57kswB8O0n008wI39S21hLwjSTRTzMjALhVSfTTzAgAbkAS/TQz+kJtbetYW9s60Na2XtaTfBaA7yuJfpoZ4RvZ1loCvqkk+mlmBAC3KomkmREA3Iwk+mFm9Ou1ta1jbW3rQFvbellP8lkAHkMS/TQzwp3b1loCHkAS/TAzAoCblEQ/zIwA4GYkkTQz+pXa2taxtrZ1rK1tvaAn+SwAjyeJfpgZ4T5tay0BjySJfpoZAcDtSaIfZkYAcBuSSJoZ/RptbetYW9s61ta2XtaTfBaAR5VEP82McD+2tZaAR5VEP8yMAOD2JJE0MwKA25BE0szoF2hrW+/V1rZe1pN8FgBISfTDzAg3b1trCXh4SSTNjADg9iSRNDMCgNuQRNLM6FO1ta0PaGtbL+hJPgsAdpJImhnhhm1rLQH4IYmkmREA3J4kkmZGAHAbkkiaGX2Strb1AW1t62U9yWcBwL8lkTQzwk3a1loCsJNE0swIAG5PEkkzIwC4DUkkzYxuQ1vbekFP8lkA8L8kkTQzwo3Z1loC8B9JJM2MAOD2JJE0MwKA25BE0szo2tra1gt6ks8CgGNJJM2McDO2tZYAHEgiaWYEALcniaSZEQDchiQzo1+prW19UE/yWQDwoiSSZka4AdtaSwBelETSzAgAbk8SSTMjALgBSSTNjH6Ntrb1QT3JZwHABZJImhnhqra1lgBcIImkmREA3J4kkmZGAHADksyMfo22tvURPclnAcDFkkiaGeFKtrWWAFwsiaSZEQDcniQzIwC4AUkkzYzeqK1tHWtrWx/Uk3wW/r89OLBtJMuWKJjlSxmUJqRpacI1qHx5fzDAAvuxehLZLZGUdCIA3COJpLbCwx1rLQG4UxJJbQUALyaJpLYCgBeQpK3uMTO2tTcztvWumbGtd8wpXwKA+yWR1FZ4oGOtJQB/JImktgKAF5NEUlsBwLMlkdRWN5sZ29qbGdvamxnbet+c8iUA+CNJJLUVHuJYawnAX0giqa0A4MUkkdRWAPBsSdrqNjNjW3szY1vvmhnbesec8iUA+AtJJLUVvtix1hKAv5ZEUlsBwItJIqmtAOCpkkhqq4/MjG29a2Zsa29mbOsdc8qXAOCvJZHUVvgyx1pLAD5JkrYCgNeTRFJbAcBTJWmrj8yMbe3NjG3tzYxtvW9O+RIAfIYkbYWvcay1BODzJJHUVgDwepJIaisAeJ4kbfWumbGtvzMztvWOOeVLAPBJkkhqK3y2Y60lAJ8tSVsBwEtK0lYA8DxJ2updM2Nbf2FmbOsdc8qXAOBTJWkrfKpjrSUAXyCJpLYCgNeTpK0A4HmStNXezNjW35kZ23rHnPIlAPhUSSS1FT7JsdYSgC+TpK0A4PUkkdRWAPAkSSS11ZeZGdt6x5zyJQD4AknaCp/hWGsJwFdKIqmtAOD1JGkrAHieJG31R2bGtv7SnPIlAPgCSSS1Ff7OsdYSgK+XpK0A4PUkaSsAeJ4kbXW/mbGtvzSnfAkAvkyStsJfONZaAvAQSSS1FQC8mCRtBQDPk6St7jcztvWX5pQvAcCXSSKprfBHjrWWADxQkrYCgBeTpK0A4HmStNWdZsa2/tKc8iUA+GJJ2gr3O9ZaAvBYSdoKAF5MEkltBQBPkqSt/svM2NbezNjW35tTvgQAXyxJW+FOx1pLAB4uiaS2AoAXk6StAOBJkrTVf8yMbb1rZmxrb2Zs631zypcA4OslkdRWuNmx1hKAJ0nSVgDwYpK0FQA8SZK2+o+Zsa29mbGtvZmxrQ/NKV8CgIdI0la4zbHWEoDnSdJWAPBikrQVADxJkrb618zY1rtmxrb2Zsa23jenfAkAHiVJW+EGx1pLAJ4qSVsBwItJ0lYA8CRJ2upfM2NbezNjW3szY1sfmlO+BACPkqSt8JFjrSUAz5akrQDgxSRpKwB4kiRtJc2Mbf2dmbGt980pXwKAB0rSVnjXsdYSgBeQRFJbAcArSdJWAPAMSdrqXzNjW39hZmzrQ3PKlwDggZJIaitsHGstAXgZSdoKAF5JEkltBQAPl6StpJmxrb8zM7b1oTnlSwDwWEnaCm851loC8EqStBUAvJgkbQUAD5ekraSZsa2/MDO29aE55UsA8HBJ2gr/41hrCcCLSdJWAPBikrQVADxckrYzY1vvmhnb2psZ2/rQnPIlAHi4JG2F/+9YawnA60nSVgDwYpK0FQA8XJK2+sjM2Nbfm1O+BADPkKSt8F+OtZYAvKQkbQUALyZJWwHAwyVpq4/MjG29a2Zs631zypcA4BmStBX+41hrCcCrStJWAPBikrQVADxckrZ618zY1rtmxrY+NKd8CQCeIUlb4V/HWksAXliStgKAF5OkrQDgsZK01UdmxrbeNTO29b455UsA8CRJ2grSsdYSgNeWpK0A4MUkaSsAeKwk/pf2Zsa23jUztvWhOeVLAPAkSdrq1zvWWgLw8pK0FQC8kiRtBQAPNzO29a6Zsa13zYxtfWhO+RIAPEmStvrdjrWWAHwHSdoKAF5JkrYCgMdK4n9pb2Zs610zY1sfmlO+BADPk6StfrFjrSUA30SStgKAV5KkrQDgsWbGtt41M7b1rpmxrQ/NKV8CgOdJ0la/1bHWEoDvI0lbAcArSdJWAPBASfwvvWtmbGtvZmzrQ3PKlwDgqZK01a90rLUE4FtJ0lYA8EqStBUAPNDM2Na7Zsa23jUztvWhOeVLAPBUSdrq9znWWgLw3SRpKwB4JUnaCgAeaGZs610zY1ufYk75EgA8VZK2+mWOtZYAfENJ2goAXkaStgKAB5oZ23rXzNjWZ5lTvgQAT5WkrX6TY60lAN9QkrYCgFeSpK0A4IFmxrbeNTO29SnmlC8BwFMlaavf5FhrCcD3lKStAOCVJGkrAHigJG21NzO29VnmlC8BwFMlaatf41hrCcC3laStAOCVJGkrAHiUJG31rpmxrY/MjG19aE75EgA8VZK2+h2OtZYAfGdJ2goAXkaStgKAB0rSVp9hZmzrQ3PKlwDgqZK01S9wrLUE4JtL0lYA8DKStBUAPEqStvoMM2Nbt5hTvgQAT5WkrX66Y60lAN9fkrYCgJeRpK0A4FGStNVnmBnbusWc8iUAeKokbfWjHWstAfj+krQVALySJG0FAI+SpK0+w8zY1ofmlC8BwFMlaasf7VhrCcCPkKStAOBlJGkrAHiUJG31kZmxrY/MjG19aE75EgA8VZK2+rmOtZYA/BRJ2goAXkaStgKAR0nSVh+ZGdt618zY1i3mlC8BwFMlaasf6lhrCcAPkqStAOBlJGkrAHiUJG31rpmxrY/MjG3dYk75EgA8VZK2+omOtZYA/CxJ2goAXkaStgKAh0jSVh+ZGdv6RHPKlwDgqZK01Y9zrLUE4GdJ0lYA8DKStBUAPEqStvrIzNjWZ5lTvgQAT5WkrX6cY60lAD9OkrYCgJeRpK0A4CGStNUNZsa2Psuc8iUAeKokbfWzHGstAfiJkrQVALyMJG0FAA+RpK0+MjO29ZGZsa1bzClfAoCnStJWP8ix1hKAHypJWwHAy0jSVgDwEEna6iMzY1sfmRnbusWc8iUAeKokbfVTHGstAfi5krQVALyGJG0FAA+RpK0+z8zY1i3mlC8BwFMlaasf4VhrCcCPlqStAOA1JGkrAHiIJG31eWbGtm4xp3wJAJ4qSVt9f8daSwB+tCRtBQCvIUlbAcCjJGmrTzIztnWLOeVLAPBUSdrq+zvWWgLw0yVpKwB4DUnaCgAeJUlbfZKZsa1bzClfAoCnStJW39yx1hKAXyBJWwHAC0jSVgDwKEna6iMzY1s3mBnbusWc8iUAeKokbfWdHWstAfgdkrQVALyAJG0FAI+SpK0+MjO2dYOZsa1bzClfAoCnStJW39ax1hKA3yFJWwHAa0jSVgDwKEna6iMzY1ufa075EgA8T5K2+raOtZYA/BpJ2goAXkCStgKAB0rSVh+ZGdv6XHPKlwDgeZK01fd0rLUE4NdI0lYA8BqStBUAPEqStvrIzNjWp5tTvgQAT5Kkrb6nY60lAL9JkrYCgBeQpK0A4IGStNVHZsa2bjMztnWLOfUPXwKAZ0jSVt/QsdYSgN8kSVsBwGtI0lYA8EBJ2uojM2Nbt5kZ27rRnPIlAHi4JG31DR1rLQH4ZZK0FQC8gCRtBQCPlaStPjIztnWbmbGtG80pXwKAh0vSVt/NsdYSgF8mSVsBwGtI0lYA8FhJ2upTzYxt3WhO+RIAPFaStvpujrWWAPw+SdoKAF5AkrYCgMdK0lafamZs63ZzypcA4LGStNW3cqy1BOD3SdJWAPAakrQVADxWkrb6VDNjW7ebU74EAA+UpK2+lWOtJQC/UpK2AoAXkKStAODhkrTVDWbGtm4wM7Z1uznlSwDwQEna6vs41loC8CslaSsAeA1J2goAHi5JW91gZmzrBjNjW7ebU//wJQB4iCRt9X0cay0B+K2StBUAvIAkbQUAz5CkrW4wM7b1ReaULwHAQyRpq2/iWGsJwG+VpK0A4DUkaSsAeIYkbXWDmbGtLzKnfAkAvl6StvomjrWWAPxiSdoKAF5AkrYCgGdI0la3mRnb+iJzypcA4Oslaavv4FhrCcAvlqStAOA1JGkrAHiGJG11m5mxrRvMjG3dZU75EgB8sSRt9R0cay0B+N2StBUAvIAkbQUAT5KkrW4zM7Z1g5mRZFu3m1P/8CUA+EpJ2urlHWstAfjdkrQVALyGJG0FAE+SpK2+wMzY1l3mlC8BwJdJ0lYv71hrCcCvl6StAOAFJGkrAHieJG31BWbGtu4yp3wJAL5MkrZ6bcdaSwB+vSRtBQAvIElbAcBTJWmrLzAzkmzrdnPqH74EAF8gSVu9tmOtJQCQkrQVALyAJG0FAE+VpK1uMzO2dbOZsa27zClfAoAvkKStXtix1hIASEnaCgBeQJK2AoBnS9JWt5kZ2/pSc+ofvgQAnypJW72wY60lAPhXkrYCgGdL0lYA8AKStNVtZsa2vtqc8iUA+FRJ2upVHWstAcC/krQVALyAJG0FAC8gSVvdZmYk2daXmlP/8CUA+CRJ2upVHWstAcB/JGkrAHi2JG0FAK8hSVvdbGZs62YzY1v3mlO+BACfJElbvaRjrSUA+I8kbQUAz5akrQDgZSRpq5vNjG3dbGYk2dZd5tQ/fAkA/lqStnpJx1pLAPAfSdoKAF5AkrYCgJeRpK1uNjO2dY+Zsa17zSlfAoC/k6StXtKx1hIA/JckbQUAz5akrQDglSRpq680M7Z1rzn1D18CgL+QpK1ez7HWEgD8lyRtBQAvIElbAcArSdJWX2lmJNnWvebUP3wJAP5IkrZ6PcdaSwDwX5K0FQC8gCRtBQAvJklbfbGZsa0/MKd8CQDul6StXs+x1hIA/H9J2goAni1JWwHA60nSVjebGdt6mDn1D18CgDslaasXc6y1BAD/X5K2AoAXkKStAOD1JGmrm82MJNt6mDn1D18CgJslaasXc6y1BAD/X5K2AoAXkKStAOAlJWmre8yMbT3SnPqHLwHADZK01Ys51loCgP+RpK0A4NmStBUAvKokktrqZjNjW/eYGUm29cfm1D98CQA+kqStXsmx1hIA/I8kbQUAz5akrQDgtSVpq5vNjCTbusfMSLKtPzan/uFLALCXpK1eybHWEgC8JUlbAcCzJWkrAHhtSdrqHjNjW3eaGUm29cfm1D98CQA2krTVyzjWWgKAtyRpKwB4tiRtBQAvL0lbPcTMSLKtPzanfAkA3pKkrV7GsdYSALwlSVsBwLMlaSsA+A6StNWjzIxtAcBnS9JWL+NYawkANpK0FQA8VZK2AoBvIklbPdDM2BYAfKokbfUajrWWAGAjSVsBwFMlaSsA+D6SSGqre8yMbf2RmZFkWwDwSZK01Ws41loCgI0kbQUAz5akrQDgW0nSVveYGUm29UdmRpJtAcBfS9JWr+FYawkA9pK0FQA8VZK2AoDvJomktrrHzEiyrT8yM5JsCwD+TpK2egHHWksAsJekrQDgqZK0FQB8T0na6k4zI8m2/sjM2BYA/IUkbfUCjrWWAGAvSVsBwFMlaSsA+LaStNX9Zsa2AOAZkrTVCzjWWgKAvSRtBQDPlqStAODbSiKprQDgm0jSVi/gWGsJAN6VpK0A4KmStBUAfHNJ2uoZZkaSbQHAzZK01bMday0BwLuStBUAPFWStgKA7y+JpLZ6hpnRv2wLAD6SpK2e7VhrCQDelaStAOCpkrQVAPwUSdrqfjNjW39tZmwLAN6VpK2e7VhrCQA+kqStAOB5krQVAPwgSSS11Z1mRpJtAcDXS9JWT3WstQQAH0nSVgDwPEnaCgB+nCRtdb+ZkWRbAPCVkrTVUx1rLQHAR5K0FQA8T5K2AoCfKImktrrfzNgWAHyZJG31VMdaSwDwkSRtBQDPk6StAODnStJW95sZSbYFAF8gSVs91bHWEgDcIElbAcCTJGkrAPjRkrTVH5kZ2wKAL5CkrZ7nWGsJAG6QpK0A4EmStBUA/HRJJLUVALyMJG31PMdaSwBwgyRtBQDPk6StAOAXSNJWf2FmJNkWAPy1JG31PMdaSwBwgyRtBQDPk6StAOB3SCKprf7CzOhftgUAfypJWz3PsdYSANwgSVsBwPMkaSsA+E2S+F/6OzMjybYA4H5J2up5jrWWAOA2SdoKAJ4kSVsBwO8zM5Js6+/MjCTbAoA7JWmrJznWWgKA2yRpKwB4kiRtBQC/1cxIsi0AeLgkbfUkx1pLAHCbJG0FAE+SpK0A4BdL4n8JAB4rSVs9ybHWEgDcJklbAcCTJGkrAPj1ZkaSbQHAoyRpqyc51loCgNskaSsAeJIkbQUAkJL4XwKAh0jSVk9yrLUEALdJ0lYA8CRJ2goA8B9J2goAvl6StnqSY60lALhNkrYCgCdJ0lYAgP+SRFJbAcBXStJWT3KstQQAN0vSVgDwDEnaCgDwP5K0nRlJtgUAXyBJWz3DsdYSANwsSVsBwDMkaSsAwFuStJU0M/qXbQHA50nSVs9wrLUEADdL0lYA8AxJ2goAsJGkrf5jZiTZFgB8hiRt9QzHWksAcLMkbQUAT5KkrQAAG0na6r/MjCTbAoC/k6StnuFYawkAbpakrQDgSZK0FQBgL0lbAcBnS9JWz3CstQQAN0vSVgDwJEnaCgDwriSS2mpjZiTZFgDcLElbPcOx1hIA3CxJWwHAkyRpKwDADZK0FQB8kiRt9QzHWksAcLMkbQUAT5KkrTZmxrb2Zsa2duaULwHAD5KkrQDgMyRpq2c41loCgJslaSsAeJIkbbUxM7a1NzO2tTOnfAkAfpYkbQUAfy1JWz3DsdYSANwsSVsBwJMkaauNmbGtvZmxrZ055UsA8OMkaSsA+DtJ2uoZjrWWAOBmSdoKAJ4kSVttzIxt7c2Mbe3MKV8CgJ8oSVsBwF9I0lbPcKy1BAD3SNJWAPAMSdpqY2Zsa29mbGtnTvkSAPxQSdoKAP5CkrZ6uGOtJQC4R5K2AoBnSNJWGzNjW3szY1s7c8qXAODnStJWAPCnkrTVwx1rLQHAPZK0FQA8Q5K22pgZ29qbGdvamVO+tDcztrUxM7YFAC8sSVsBwJ9K0lYPd6y1BAD3SNJWAPAMSdpqY2Zsa29mbGtnTvnS3szY1sbM2BYAvLYkbQUAfyRJWz3csdYSANwjSVsBwDMkaauNmbGtvZmxrZ055Ut7M2NbGzNjWwDw8pK0FQDcL0lbPdyx1hIA3CNJWwHAMyRpq42Zsa29mbGtnTnlS3szY1sbM2NbAPAdJGkrALhTkrZ6uGOtJQC4R5K2AoBnSNJWX2RO+dLezNjWxszYFgB8E0naCgDukaStHu5YawkA7pGkrQDgGZK01ReZU760NzO2tTEztgUAAPBzJWmrhzvWWgIAAPgmkrTVF5lTvrQ3M7a1MTO2BQAAgM92rLUEAADwTSRpqy8yp3xpb2Zsa2NmbAsAAACf7VhrCQAA4JtI0lZfZE750t7M2NbGzNgWAAAAPtux1hIA3CNJW23MjG3tzYxt7cwpXwKAjSRttTEztrU3M7a1M6d8aW9mbGtjZmwLAADg50rSVhszY1t7M2NbO3PKl95yrLUEAPdI0lYbM2NbezNjWztzypcAYCNJW23MjG3tzYxt7cwpXwIAAMBGkrbamBnb2psZ29qZU770lmOtJQC4R5K22pgZ29qbGdvamVO+BAAbSdpqY2Zsa29mbGtnTvkSAAAANpK01cbM2NbezNjWzpzypbccay0BwD2StNXGzNjW3szY1s6c8iUA2EjSVhszY1t7M2NbO3PKlwAAALCRpK02Zsa29mbGtnbmlC+95VhrCQDukaStNmbGtvZmxrZ25pQvAcBGkrbamBnb2psZ29qZU74EAACAjSRttTEztrU3M7a1M6d86S3HWksAcI8kbbUxM7a1NzO2tTOnfAkANpK01cbM2NbezNjWzpzyJQAAAGwkaauNmbGtvZmxrZ055UtvOdZaAoB7JGmrjZmxrb2Zsa2dOeVLALCRpK02Zsa29mbGtnbmlC/tzYxtbcyMbQEAAPxcSdpqY2Zsa29mbGtnTvnSW461lgDgHknaamNmbGtvZmxrZ075EgBsJGmrjZmxrb2Zsa2dOeVLezNjWxszY1sAAAA/V5K22pgZ29qbGdvamVO+9JZjrSUAuEeSttqYGdvamxnb2plTvgQAG0naamNmbGtvZmxrZ0750t7M2NbGzNgWAADAz5WkrTZmxrb2Zsa2duaUL73lWGsJAO6RpK02Zsa29mbGtnbmlC8BwEaSttqYGdvamxnb2plTvrQ3M7a1MTO2BQAA8HMlaauNmbGtvZmxrZ055UtvOdZaAoB7JGmrLzKnfAkANpK01ReZU760NzO2tTEztgUAAPBzJWmrLzKnfOktx1pLAHCPJG31ReaULwHARpK2+iJzypf2Zsa2NmbGtgAAAH6uJG31ReaUL73lWGsJAO6RpK2+yJzyJQDYSNJWX2RO+dLezNjWxszYFgAAwM+VpK2+yJzypbccay0BwD2StNUXmVO+BAAbSdrqi8wpX9qbGdvamBnbAgAA+LmStNUXmVO+9JZjrSUAuEeStvoic8qXAGAjSVt9kTnlS3szY1sbM2NbAAAAP1eStvoic8qX3nKstQQA90jSVhszY1t7M2NbO3PKlwBgI0lbbcyMbe3NjG3tzClf2psZ29qYGdsCAAD4uZK01cbM2NbezNjWzpzypbccay0BwD2StNXGzNjW3szY1s6c8iUA2EjSVhszY1t7M2NbO3PKlwAAALCRpK02Zsa29mbGtnbmlC+95VhrCQDukaStNmbGtvZmxrZ25pQvAcBGkrbamBnb2psZ29qZU74EAACAjSRttTEztrU3M7a1M6d86S3HWksAcI8kbbUxM7a1NzO2tTOnfAkANpK01cbM2NbezNjWzpzyJQAAAGwkaauNmbGtvZmxrZ055UtvOdZaAoB7JGmrjZmxrb2Zsa2dOeVLALCRpK02Zsa29mbGtnbmlC8BAABgI0lbbcyMbe3NjG3tzClfesux1hIA3CNJW23MjG3tzYxt7cwpXwKAjSRttTEztrU3M7a1M6d8CQAAABtJ2mpjZmxrb2Zsa2dO+dJbjrWWAOAeSdpqY2Zsa29mbGtnTvkSAGwkaauNmbGtvZmxrZ055Ut7M2NbGzNjWwAAAD9XkrbamBnb2psZ29qZU770lmOtJQC4R5K22pgZ29qbGdvamVO+BAAbSdpqY2Zsa29mbGtnTvnS3szY1sbM2BYAAMDPlaStNmbGtvZmxrZ25pQvveVYawkA7pGkrTZmxrb2Zsa2duaULwHARpK22pgZ29qbGdvamVO+tDcztrUxM7YFAADwcyVpq42Zsa29mbGtnTnlS2851loCgHskaauNmbGtvZmxrZ055UsAsJGkrTZmxrb2Zsa2duaUL+3NjG1tzIxtAQAA/FxJ2mpjZmxrb2Zsa2dO+dJbjrWWAOAeSdrqi8wpXwKAjSRt9UXmlC/tzYxtbcyMbQEAAPxcSdrqi8wpX3rLsdYSANwjSVt9kTnlSwCwkaStvsic8qW9mbGtjZmxLQAAgJ8rSVt9kTnlS2851loCgHskaasvMqd8CQA2krTVF5lTvrQ3M7a1MTO2BQAA8HMlaasvMqd86S3HWksAcI8kbfVF5pQvAcBGkrb6InPKl/ZmxrY2Zsa2AAAAfq4kbfVF5pQvveVYawkA7pGkrb7InPIlANhI0lZfZE750t7M2NbGzNgWAADAz5Wkrb7InPKltxxrLQHAPZK01cbM2NbezNjWzpzyJQDYSNJWGzNjW3szY1s7c8qX9mbGtjZmxrYAAAB+riRttTEztrU3M7a1M6d86S3HWksAcI8kbbUxM7a1NzO2tTOnfAkANpK01cbM2NbezNjWzpzyJQAAAGwkaauNmbGtvZmxrZ055UtvOdZaAoB7JGmrjZmxrb2Zsa2dOeVLALCRpK02Zsa29mbGtnbmlC8BAABgI0lbbcyMbe3NjG3tzClfesux1hIA3CNJW23MjG3tzYxt7cwpXwKAjSRttTEztrU3M7a1M6d8CQAAABtJ2mpjZmxrb2Zsa2dO+dJbjrWWAOAeSdpqY2Zsa29mbGtnTvkSAGwkaauNmbGtvZmxrZ055UsAAADYSNJWGzNjW3szY1s7c8qX3vJ/3BSh0AVWmekAAAAASUVORK5CYII=",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from metaurban.envs.base_env import BaseEnv\n",
    "from metaurban.obs.observation_base import DummyObservation\n",
    "import logging\n",
    "\n",
    "# ======================================== new content ===============================================\n",
    "import cv2\n",
    "from metaurban.component.map.pg_map import PGMap\n",
    "from metaurban.manager.base_manager import BaseManager\n",
    "from metaurban.component.pgblock.first_block import FirstPGBlock\n",
    "\n",
    "class MyMapManager(BaseManager):\n",
    "    PRIORITY = 0\n",
    "\n",
    "    def __init__(self):\n",
    "        super(MyMapManager, self).__init__()\n",
    "        self.current_map = None\n",
    "        self.all_maps = {idx: None for idx in range(3)} # store the created map\n",
    "        self._map_shape = [\"X\", \"T\", \"O\"] # three types of maps \n",
    "\n",
    "    def reset(self):\n",
    "        idx = self.engine.global_random_seed % 3\n",
    "        if self.all_maps[idx] is None:\n",
    "            # create maps on the fly\n",
    "            new_map = PGMap(map_config=dict(type=PGMap.BLOCK_SEQUENCE,\n",
    "                                            config=self._map_shape[idx]))\n",
    "            self.all_maps[idx] = new_map\n",
    "\n",
    "        # attach map in the world\n",
    "        map = self.all_maps[idx]\n",
    "        map.attach_to_world()\n",
    "        self.current_map = map\n",
    "        return dict(current_map=self._map_shape[idx])\n",
    "\n",
    "    def before_reset(self):\n",
    "        if self.current_map is not None:\n",
    "            self.current_map.detach_from_world()\n",
    "            self.current_map = None\n",
    "\n",
    "    def destroy(self):\n",
    "        # clear all maps when this manager is destroyed\n",
    "        super(MyMapManager, self).destroy()\n",
    "        for map in self.all_maps.values():\n",
    "            if map is not None:\n",
    "                map.destroy()\n",
    "        self.all_maps = None\n",
    "\n",
    "\n",
    "# Expand the default config system, specify where to spawn the car\n",
    "MY_CONFIG = dict(agent_configs={\"default_agent\": dict(spawn_lane_index=(FirstPGBlock.NODE_1, FirstPGBlock.NODE_2, 0))}) \n",
    "\n",
    "\n",
    "class MyEnv(BaseEnv):\n",
    "    \n",
    "    @classmethod\n",
    "    def default_config(cls):\n",
    "        config = super(MyEnv, cls).default_config()\n",
    "        config.update(MY_CONFIG)\n",
    "        return config\n",
    "    \n",
    "    def setup_engine(self):\n",
    "        super(MyEnv, self).setup_engine()\n",
    "        self.engine.register_manager(\"map_manager\", MyMapManager())\n",
    "        \n",
    "# ======================================== new content ===============================================\n",
    "\n",
    "    def reward_function(self, agent):\n",
    "        return 0, {}\n",
    "\n",
    "    def cost_function(self, agent):\n",
    "        return 0, {}\n",
    "\n",
    "    def done_function(self, agent):\n",
    "        return False, {}\n",
    "    \n",
    "    def get_single_observation(self):\n",
    "        return DummyObservation()\n",
    "        \n",
    "\n",
    "if __name__==\"__main__\":\n",
    "    frames = []\n",
    "    \n",
    "    # create env\n",
    "    env=MyEnv(dict(crswalk_density=1.,\n",
    "                   use_render=False, # if you have a screen and OpenGL suppor, you can set use_render=True to use 3D rendering  \n",
    "                   manual_control=True, # we usually manually control the car to test environment\n",
    "                   num_scenarios=4,\n",
    "                   log_level=logging.CRITICAL)) # suppress logging message\n",
    "    for i in range(4):\n",
    "        \n",
    "        # reset\n",
    "        o, info = env.reset(seed=i)\n",
    "        print(\"Load map with shape: {}\".format(info[\"current_map\"]))\n",
    "        # you can set window=True and remove generate_gif() if you have a screen. \n",
    "        # Or just use 3D rendering and remove all stuff related to env.render()  \n",
    "        frame=env.render(mode=\"topdown\", \n",
    "                         window=False, # turn me on, if you have screen\n",
    "                         scaling=3,\n",
    "                         camera_position=(50, 0),\n",
    "                         screen_size=(400, 400))\n",
    "        frames.append(frame)\n",
    "    cv2.imwrite(\"demo.png\",  cv2.cvtColor(cv2.hconcat(frames), cv2.COLOR_RGB2BGR))\n",
    "    env.close()\n",
    "\n",
    "from IPython.display import Image\n",
    "Image(open(\"demo.png\", 'rb').read())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d074ecb-ebca-403b-8e23-804529332232",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "The results show 4 scenarios and the 4th scenario is the same as the first one, as we repeatedly load the 3 maps according to `MyMapManager.reset()`.\n",
    "This function also returns the shape of the current map, which you can access in the `info` returned by `env.step()`.\n",
    "**Thus, in your own development, you can collect simulation information and return them by `env.step()` by returning a dictionary in these functions: `before_step`, `step`, `after_step`, `before_reset`, `reset`, `after_reset`.**\n",
    "Another thing to take care of is that we overwrite the original `agent_configs` of `BaseEnv`.\n",
    "It defines where to spawn the agent with the id `default_agent`.\n",
    "You can create maps automatically with `PGMap` which combines some predefined blocks."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88e2a670",
   "metadata": {},
   "source": [
    "## AssetManager\n",
    "Compared to the last code cell, we add a asset manager to generate different objects on sidewalk for each seed. New content added upon the last code cell are marked between two `======`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0025e122",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[38;20m[INFO] Environment: MyEnv\u001b[0m\n",
      "\u001b[38;20m[INFO] MetaUrban version: 0.0.1\u001b[0m\n",
      "\u001b[38;20m[INFO] Sensors: [lidar: Lidar(), side_detector: SideDetector(), lane_line_detector: LaneLineDetector()]\u001b[0m\n",
      "\u001b[38;20m[INFO] Render Mode: none\u001b[0m\n",
      "\u001b[38;20m[INFO] Horizon (Max steps per agent): None\u001b[0m\n",
      "\u001b[33;20m[WARNING] You are using DummyObservation which doesn't collect information from the environment. (observation_base.py:50)\u001b[0m\n",
      "\u001b[38;20m[INFO] Assets version: 0.0.1\u001b[0m\n",
      "\u001b[38;20m[INFO] Known Pipes: glxGraphicsPipe\u001b[0m\n",
      "\u001b[33;20m[WARNING] Can not find `start_seed` or `start_scenario_index`. Use 0 as `start_seed` (base_engine.py:577)\u001b[0m\n",
      "\u001b[38;20m[INFO] Start Scenario Index: 0, Num Scenarios : 4\u001b[0m\n",
      "\u001b[33;20m[WARNING] Can not find `start_seed` or `start_scenario_index`. Use 0 as `start_seed` (base_engine.py:577)\u001b[0m\n",
      "\u001b[33;20m[WARNING] Can not find `start_seed` or `start_scenario_index`. Use 0 as `start_seed` (base_engine.py:577)\u001b[0m\n",
      "\u001b[33;20m[WARNING] Can not find `start_seed` or `start_scenario_index`. Use 0 as `start_seed` (base_engine.py:577)\u001b[0m\n",
      "\u001b[33;20m[WARNING] Can not find `start_seed` or `start_scenario_index`. Use 0 as `start_seed` (base_engine.py:577)\u001b[0m\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from metaurban.envs.base_env import BaseEnv\n",
    "from metaurban.obs.observation_base import DummyObservation\n",
    "import logging\n",
    "\n",
    "# ======================================== new content ===============================================\n",
    "import cv2\n",
    "from metaurban.manager.sidewalk_manager import AssetManager\n",
    "\n",
    "class MyAssetManager(AssetManager):\n",
    "    PRIORITY = 9\n",
    "\n",
    "    def __init__(self):\n",
    "        super(MyAssetManager, self).__init__()\n",
    "\n",
    "\n",
    "    def reset(self):\n",
    "        super(MyAssetManager, self).reset()\n",
    "\n",
    "# Expand the default config system, specify where to spawn the car\n",
    "MY_CONFIG = dict(agent_configs={\"default_agent\": dict(spawn_lane_index=(FirstPGBlock.NODE_1, FirstPGBlock.NODE_2, 0))}, object_density=0.3) \n",
    "\n",
    "class MyEnv(BaseEnv):\n",
    "    \n",
    "    @classmethod\n",
    "    def default_config(cls):\n",
    "        config = super(MyEnv, cls).default_config()\n",
    "        config.update(MY_CONFIG)\n",
    "        return config\n",
    "    \n",
    "    def setup_engine(self):\n",
    "        super(MyEnv, self).setup_engine()\n",
    "        self.engine.register_manager(\"map_manager\", MyMapManager())\n",
    "        self.engine.register_manager(\"asset_manager\", MyAssetManager())\n",
    "        \n",
    "# ======================================== new content ===============================================\n",
    "\n",
    "    def reward_function(self, agent):\n",
    "        return 0, {}\n",
    "\n",
    "    def cost_function(self, agent):\n",
    "        return 0, {}\n",
    "\n",
    "    def done_function(self, agent):\n",
    "        return False, {}\n",
    "    \n",
    "    def get_single_observation(self):\n",
    "        return DummyObservation()\n",
    "        \n",
    "\n",
    "if __name__==\"__main__\":\n",
    "    frames = []\n",
    "    \n",
    "    # create env\n",
    "    env=MyEnv(dict(crswalk_density=1.,\n",
    "                   use_render=False, # if you have a screen and OpenGL suppor, you can set use_render=True to use 3D rendering  \n",
    "                   manual_control=True, # we usually manually control the car to test environment\n",
    "                   num_scenarios=4)) # suppress logging message\n",
    "    for i in range(4):\n",
    "        \n",
    "        # reset\n",
    "        o, info = env.reset(seed=i)\n",
    "        # you can set window=True and remove generate_gif() if you have a screen. \n",
    "        # Or just use 3D rendering and remove all stuff related to env.render()  \n",
    "        frame=env.render(mode=\"topdown\", \n",
    "                         window=False, # turn me on, if you have screen\n",
    "                         scaling=3,\n",
    "                         camera_position=(50, 0),\n",
    "                         screen_size=(400, 400))\n",
    "        frames.append(frame)\n",
    "    cv2.imwrite(\"demo.png\",  cv2.cvtColor(cv2.hconcat(frames), cv2.COLOR_RGB2BGR))\n",
    "    env.close()\n",
    "\n",
    "from IPython.display import Image\n",
    "Image(open(\"demo.png\", 'rb').read())"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "metaurban",
   "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.16"
  },
  "mystnb": {
   "execution_mode": "off"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}