{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<div class=\"alert alert-info\">\n",
    "\n",
    "**This is a fixed-text formatted version of a Jupyter notebook**\n",
    "\n",
    "- Try online [![Binder](https://static.mybinder.org/badge.svg)](https://mybinder.org/v2/gh/gammapy/gammapy-webpage/v0.17?urlpath=lab/tree/exclusion_mask.ipynb)\n",
    "- You can contribute with your own notebooks in this\n",
    "[GitHub repository](https://github.com/gammapy/gammapy/tree/master/tutorials).\n",
    "- **Source files:**\n",
    "[exclusion_mask.ipynb](../_static/notebooks/exclusion_mask.ipynb) |\n",
    "[exclusion_mask.py](../_static/notebooks/exclusion_mask.py)\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating exclusion masks\n",
    "\n",
    "## Introduction\n",
    "\n",
    "### Prerequisites\n",
    "\n",
    "- Understanding of basic analyses in 1D or 3D.\n",
    "- Usage of `~regions` and catalogs, see the [catalog notebook](catalog.ipynb). \n",
    "\n",
    "### Context\n",
    "\n",
    "Background templates stored in the DL3 IRF are often not reliable enough to be used without some corrections. A set of common techniques to perform background or normalisation from the data is implemented in gammapy: reflected regions for 1D spectrum analysis, field-of-view (FoV) background or ring background for 2D and 3D analyses.\n",
    "\n",
    "To avoid contamination of the background estimate from gamma-ray bright regions these methods require to exclude those regions from the data used for the estimation. To do so, we use exclusion masks. They are maps containing boolean values where excluded pixels are stored as False.  \n",
    "\n",
    "**Objective: Build an exclusion mask around the Crab nebula excluding gamma-ray sources in the region.**\n",
    "\n",
    "### Proposed approach\n",
    "\n",
    "Here we have to build a `Map` object, we must first define its geometry and then we can determine which pixels to exclude.\n",
    "\n",
    "We can rely on known sources positions and properties to build a list of regions (here `~regions.SkyRegions`) enclosing most of the signal that our detector would see from these objects. We show below how to build this list manually or from an existing catalog. \n",
    "\n",
    "Finally, we show how to build the mask from a `MapDataset`, finding pixels which contain statistically significant signal. To do so, we use the `ExcessMapEstimator`\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from astropy.coordinates import SkyCoord, Angle\n",
    "from regions import read_ds9, CircleSkyRegion\n",
    "from gammapy.maps import Map, WcsGeom\n",
    "from gammapy.utils.regions import make_region\n",
    "from gammapy.catalog import SOURCE_CATALOGS\n",
    "from gammapy.datasets import Datasets\n",
    "from gammapy.estimators import ExcessMapEstimator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create the mask from a list of regions\n",
    "\n",
    "One can build an exclusion mask from regions. We show here how to proceed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define the geometry\n",
    "\n",
    "Exclusions masks are stored in `Map` objects. One has therefore to define the geometry to use. Here we consider a region at the Galactic anticentre around the crab nebula."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "position = SkyCoord(83.633083, 22.0145, unit=\"deg\", frame=\"icrs\")\n",
    "geom = WcsGeom.create(\n",
    "    skydir=position, width=\"5 deg\", binsz=0.02, frame=\"galactic\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create the list of regions\n",
    "\n",
    "A useful function to create region objects is `~gammapy.utils.regions.make_region`. It can take strings defining regions following the \"ds9\" format and convert them to `regions`. \n",
    "\n",
    "Here we use a region enclosing the Crab nebula with 0.3 degrees. The actual region size should depend on the expected PSF of the data used. We also add another region with a different shape as en example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[<RectangleSkyRegion(<SkyCoord (Galactic): (l, b) in deg\n",
      "    (185., -4.)>, width=1.0 deg, height=0.5 deg, angle=45.0 deg)>, <CircleSkyRegion(<SkyCoord (ICRS): (ra, dec) in deg\n",
      "    (83.633083, 22.0145)>, radius=0.3 deg)>]\n"
     ]
    }
   ],
   "source": [
    "some_region = make_region(\"galactic;box(185,-4,1.0,0.5, 45)\")\n",
    "crab_region = make_region(\"icrs;circle(83.633083, 22.0145, 0.3)\")\n",
    "regions = [some_region, crab_region]\n",
    "print(regions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Equivalently the regions can be read from a ds9 file, this time using `regions.read_ds9`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# regions = read_ds9('ds9.reg')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create the mask map \n",
    "\n",
    "We can now create the map. We use the `WcsGeom.region_mask` method putting all pixels inside the regions to False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "mask_data = geom.region_mask(regions, inside=False)\n",
    "mask_map = Map.from_geom(geom, data=mask_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<Figure size 432x288 with 1 Axes>,\n",
       " <matplotlib.axes._subplots.WCSAxesSubplot at 0x11bb85f60>,\n",
       " None)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "mask_map.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create the mask from a catalog of sources\n",
    "\n",
    "We can also build our list of regions from a list of catalog sources. Here we use the Fermi 4FGL catalog which we read using `~gammapy.catalog.SourceCatalog`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "fgl = SOURCE_CATALOGS.get_cls(\"4fgl\")()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now select sources that are contained in the region we are interested in."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "inside_geom = geom.contains(fgl.positions)\n",
    "idx = np.where(inside_geom)[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now create the list of regions using our 0.3 degree radius a priori value. If the sources were extended, one would have to adapt the sizes to account for the larger size."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "exclusion_radius = Angle(\"0.3 deg\")\n",
    "regions = [CircleSkyRegion(fgl[i].position, exclusion_radius) for i in idx]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can build the mask map the same way as above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "mask_data = geom.region_mask(regions, inside=False)\n",
    "mask_map_catalog = Map.from_geom(geom, data=mask_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<Figure size 432x288 with 1 Axes>,\n",
       " <matplotlib.axes._subplots.WCSAxesSubplot at 0x11bdfd0f0>,\n",
       " None)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "mask_map_catalog.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Combining masks\n",
    "\n",
    "If two masks share the same geometry it is easy to combine them with `Map` arithmetics."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<Figure size 432x288 with 1 Axes>,\n",
       " <matplotlib.axes._subplots.WCSAxesSubplot at 0x11cf12da0>,\n",
       " None)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQwAAAEHCAYAAABbS3hQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAVC0lEQVR4nO3deZgkdX3H8feHRVh2OcLM4i1sm6ioCawyyK0bMAioTyAQs57BA4wuGvDBA3M8oj6JAYkm7hpMeBTiLWFDlCjgBYoiOKy7LIiPGgY84BHtUdkDxd395o+qXmqHnp5fz3RVV/d8Xs9Tz9RdX2anP1T9uupXigjMzFLs0u8CzGxwODDMLNlAB4akzf2uIdUg1QqDVe8g1QqDV2/RQAeGmVXLgWFmyTRo35KMjo5ubzQaApiYmKDRaPS7pCRV1DoxMdGT/TQaDf9uSzQI9U5MTESz2XzYCcWu/ShmLhqNhsbHx/tdRu1I6tm+JicnGbT/kVhvjY2Ntf2D8iXJEOhlWJh14sAYcGWFhSQHkT2MA2OA+QNtVXNgmFkyB4aZJXNgDChfjlg/ODDMLJkDw7rmb1DmLweGJZsaFA6N+ceBYUmmCweHxvziwLAZzRQKDo35w4ExoKp61iM1DBwa84MDw3rGoTH8HBjWUw6N4ebAGGB1fQTdoTG8HBgDzqFhVXJgDAGHhlXFgTEkHBpWBQfGEHFoWNkcGEPGoWFlcmAMoYjYMdSJQ2PwDVyv4dadTqHhD7B1y4ExDzkobLZ8STLP9DMs6naJZN1zYMwjDgubKwfGPOGwsF6oPDAkHSppm6TTCvNWSFor6eyq67FyOSyGS6WBIWkB8E/ANVMWrQAOBQ6XtGeVNc0H/Tq7cFgMn6rPMN4AXAHcN2V+6y86CuPWAw4L66XKAkPS44BTgIvbLF4DjAPjEbGxqpqGWT979nZYDK8q78N4P/DWiNg29Q85Ii4DLptuQ0mbW+MjIyOlFTgs3MBpczUxMbHT5y4iFkPJgSFpJXBGPrkP8Kn8j3kJcJKkrRFx5Uz7aRULMDY25r/IDhwW1guNRoNms7l46vxSAyMiVgOrp86XdClwVUpY2GBwWMwPvg9jiLjNwsrWl2dJIuL0fhx3mDksrAp++GzAuc3CquRLkgHmsLCqOTCsaw6L+cuBMcD68cF1WMxvDowBV+UH2GFhDowhUMUH2WFh4MAYGmV+oB0W1uLAGCJlfLAdFlbkwBgyvfyAOyxsKgfGEOrFB91hYe04MIbUXD7wDgubjgNjiM3mg++wsE4cGEOumwBwWNhMHBjzQEoQOCwshQNjnugUCA4LS+XAmEfaBYPDwrrhwJhnigHhsLBuuQOdechBYbPlMwwzS+bAMLNkDgwzS+bAMLNkDgwzS+bAMLNkDgwzS+bAMLNkDgwzS+bAMLNkDgwzS+bAMLNkDgwzS5YUGJIOkPTcfHwPSXuVW5aZ1dGMgSHpDOC/gA/lsx4PXFlmUWZWTylnGCuBo4D7ASLiB8AjyyzKzOopJTB+GxEPtiYk7Qp03QOLpOWSfi1pXT78fWHZCklrJZ3d7X7NrDopPW5dL+ntwB6S/gR4PfC5WR7v6xHxgjbzVwCHAh+XtGdEbJrl/s2sRClnGG8Dfg5sAF4LfB742x7XofxnFMbNrGZmPMOIiO3Af+TDXB0haT1wD3BuRNyez18DjAMfi4iNPTiOmZVA03UIK2kDHdoqIuKgrg4k7Q1sj4hNkk4C/iUinpS47ebW+MjIyKJms9nNoc2sS6Ojo0xOTm5pTUfEYuh8htFqa1iZ//xo/vOlwJaHr/5wklYCZ+STJ0XEPfnBPy/pg5KWRMQvZtpPq1iAsbExd3ltVrJGo0Gz2Vw8df60gRERdwNIOioijiosepukbwDvnOmgEbEaWJ3v59GSFBEh6Vlk7Sc+VTAbICnfkiyWdHRE3AAg6UjgYcmT4DTgdZK2Ag8AK8IvyDAbKCmB8Wrgw5L2yad/Bbyq2wNFxCpgVbfbmVl9pHxLcgtwcN5oqYj4dfllmVkdzRgYxTsy82kAImLGNgwzGy4plySbC+MLyb49uaOccsyszlIuSS4qTkt6L/DZ0ioys9qaTQc6i4An9roQM6u/lDaM4h2fC4D9gHeVWZSZ1VNKG0bx6dKtwM8iYmtJ9ZhZjaVckrw7Iu7Oh59GxFZJH515MzMbNimB8fTiRN6BziHllGNmdTZtYEg6T9JG4CBJ9+fDRuBnwP9UVqGZ1ca0gRER/xgRewEXRsTe+bBXRIxGxHkV1mhmNTFto6ekAyPie8Dlkp45dXlErC21MjOrnU7fkrwJOBO4qM2yAI4tpSIzq61O/WGcmY+eGBG/KS6TtLDUqsysllK+Jflm4jwzG3Kd2jAeDTyO7PUCz+Ch3rz3Jrs93MzmmU5tGM8DTid7NeI/F+ZvBN5eYk02BFrdILTjjtYGV6c2jMuAyySdGhFXVFiTDahOIdFuPQfH4El5vP0KSc8nu+NzYWG+O9AxID0optvOwTE4Up5WvZiszeKPgUvIOvO9ueS6bADMNiim24+Do/5SviU5MiJeAfwyIs4HjgCeUG5ZZlZHKYHxQP5zi6THAr8DGuWVZIOgV2cXZe/TeiulP4yrJP0ecCGwluwuz168Z9XMBkxKo2erd60rJF1F1vB5YKlVWa2VeSYgyW0ZNdZVn54R8dv8vSSXl1SPmdXYbDoBhofu+jTrObdl1NdsA8PnjPOUP8zzW6dnST5H+2AQMFpaRWZWW50aPd87y2VmNqQ6PUtyfZWFmFn9zbYNw8zmIQeGmSVzYFhXqripyjdu1deMgSHpi/mt4a3pfSVdU25ZZlZHKWcYSyLiV62JiPgl8MjySjKzukoJjO2S9m9NSDqAWd64JWm5pHWSbpd0fWH+CklrJZ09m/1atcq8ZPDlSL2lPK36N8ANhQ/4s8neV9KV/LLmg8AJEfEjScWzlBXAocDHJe0ZEZu63b9VKyJ6ftenw6L+Up5WvTp/89nhZHd5nhMRv5jFsV4CrImIH+X7va+wrPWXF/g5FbPa6vQy5gPzn88E9gfuAX4K7N/u1YkJngzsK+k6SbdIekVh2RpgHBiPiI2z2LeZVUDTnQZK+veIOFPSV9ssjojo6lWJklYBY8BxwB7AjcDzI+L7Cdtubo2PjIwsajab3RzaKjDbyxNfhtTT6Ogok5OTW1rTEbEYSn5VoqSVwBn55GeAqyNiM7BZ0teAg4EZA6NVLMDY2Jj/wmpoNm0aDov6ajQaNJvNxVPnl/qqxIhYHRHLImIZ8N/AMZJ2lbQIOAy4I2U/NhgiYscwl3Wsvip7VWJE3CHpauBWYDtwSUTc1n3JNggcCMMp9VWJF/FQYNzPLF+VGBEXknUmbGYDyK9KNLNkKW0Yh7R5luTdJdZkZjWVEhgntnmW5KTySjKzukoJjAWSdm9NSNoD2L3D+mY2pFKeJfkY8GVJHyG7dftVwGWlVmVmtZTyLMkFkjaQ3aEp4F0R4f4wzOahlDMMIuILwBdKrsXMai6lx63DJX1b0iZJD0raJun+Koozs3pJafRcBbwY+AHZQ2OvAT5QZlFmVk+plyQ/lLQgIrYBH5GU9CyJmQ2XlMDYImk3YJ2kC4B7gYc9xWZmwy/lkuTlwALgLGAz8ATg1DKLMrN6Svla9e589AHg/HLLMbM66/R4+wY69A4eEQeVUpGZ1VanM4wXVFaFmQ2ETo+33z3dMjObn3zjlpkl841bZpbMN26ZWTLfuGVmyVJv3NoF37hlNu91c+PWb/CNW2bzWqd3q/5p/uay1vRNku7Mh9OqKc/M6qTTJclbgM8WpncHDgWWA68rsSazoSZpxqGuOl2S7BYRPy5M3xARTaApyY2eZl3qJggk1fLtcZ3OMPYtTkTEWYXJ/copx2w4zeasoY5nG50C4yZJZ0ydKem1wM3llWQ2XOb6oa9TaHS6JDkHuFLSS4C1+bxDyNoyTi67MLNh0KsPe10uUTo9fHYfcKSkY4Gn57P/NyK+UkllZgOu12cGdQiNlPswvgI4JMy6UNZlRL9DI+VOTzOrkX62aTgwzHqsTo2UvebAMLNkDgwzS1ZZYEh6s6R1+XBb3nPXSL5shaS1ks6uqh6zMgzz5QhUGBgRcWFELIuIZcB5wPURMZkvXkH2nMrhkvasqiYz606/LkleDHyyMN2K5SiMm1nNVB4YkhYBJwBXFGavAcaB8YjYWHVNZpZGVd8EIukvgJdFxAu72GZza3xkZGRRs9kspTazuaqqDaPsz+3o6CiTk5NbCsdbDCWfYUhaWWjofGw+ewU7X47MKCIWt4ZGo9H7Qs16pN+3bvdKo9HY6XPXmp/Ua/hsRcRqYHVrWtI+wHOAl5V5XDMrR9VtGKcA10bE5hnXNLPaqTQwIuLSiFhR5THNqjYslyXt+E5PsxKUFRoR4adVzYbRMJ5pODDMStTL0KhDADkwzErWiw96HcICSv5a1czmpi5B0eIzDLMKzKaxsm5hAT7DMKtUMQTa3UZex5AocmCY9Undw6EdX5KYWTIHhpklc2CYWTIHhpklc2CYWTIHhpklc2CYWTIHhpklc2CYWTIHhpklc2CYWTIHhpklc2CYWTIHhpklc2CYWTIHhpklc2CYWTIHhpklc2CYWTIHhpklc2CYWTIHhpklc2CYWTIHhpklc2CYWTIHhpklc2CYWbLKAkPSPpI+J2m9pNslvbKwbIWktZLOrqoeM+telWcYK4HvRsTBwHLgIkm75ctWAIcCh0vas8KazKwLVQZGAHspe8f9nsAksDVfpsI6arOtmdVAlYGxCngqcA+wAfjriNieL1sDjAPjEbGxwprMrAuKiGoOJJ0GHAW8Cfh94IvAwRFxf8K2m1vjIyMji5rNZml1mhmMjo4yOTm5pTUdEYuh5DMMSSslrZO0jqwNY01kfghMAAem7CciFreGRqNRZslmBjQajZ0+d635pQZGRKyOiGURsQz4HnAcgKRHAU8B7izz+GbWW7tWeKx3AZdK2kDWsPnWiPhFhcc3szmqLDAi4h7g+KqOZ2a95zs9zSyZA8PMkjkwzCyZA8PMkjkwzCyZA8PMkjkwzCxZZc+S9MqSJUti6dKlO6YnJiYYlNvFXWs5XGvvTUxMRLPZfNgJxcAFxlSSNhfvda8z11oO11odX5KYWTIHhpklG/hLEjOrjs8wzCyZA8PMkjkwzCxZLQND0ocl3SfptsK8ZZK+lXf5Ny7pWfn8l7a6AcyH7ZKW5cuW5+teUIda82UHSboxfzfLBkkL61irpKWSHij8Xi8ubFOrWgvL95e0SdK5da1V0rMKv9P1kk6pstY5i4jaDcCzgWcCtxXmXQucmI+fBFzXZrs/Au4sTH8a2AO4CDiw37WSdVh0K1nnxwCjwIKa1rq0uN6U/dSq1sLyK4DLgXPrWiuwCNg1H38McF9huvRa5zrU8gwjIr5G9t6SnWYDe+fj+5C9rmCqFwOfLEzvkm+3nZLed9JlrccDt0bE+nzbZkRsq2mtndSuVkknk/URe3uda42ILRHReh/Pwny9ymqds34nVofUXsrOif1U4EfAj4GfAge02eb/gD8sTD8PWAtcVIdagbOBjwLX5HW9pca1LgU2A98BrgeOqXGti4EbyV6Q9Q52PsOoVa35ssPIgm0TcErVtc7pv7PfBXTxD/CvwKn5+IuAL01Z/zBgQ51rBc4le73CErJT0xuB42pa6+7AaD5+SP6Hv3dNa30v8KJ8fKfAqFutU7Z5KnAzsLDqemf939nvArr4B/g1D91oJuD+Keu/D3h7nWsle4fspYX1/g54cx1rbbPddcBYHWsFvg7clQ+/Irs8OKuOtbbZ7qtV/17nMtSyDWMa9wDPycePBX7QWiBpF+DPgU/1oa52pqv1GuAgSYsk7Zqv890+1FfUtlZJ+0lakI8/EXgS/X+PTNtaI+KYiFgaEUuB9wP/EBGr+lPiDtP9Xhv5vz2SDiB7P89d/ShwVvqdWNOk7ieBe4HfAT8BXg0cDdwCrAduAg4prL8c+NaA1PoysuvX24AL6lorcGpe53qy6+oX1rXWKdu9g4ovSbr8vb48/72uy3+vJ/fj73a2g58lMbNkg3RJYmZ95sAws2QODDNL5sAws2QODDNL5sAws2QOjAEi6VGSPiHpTkm35I/JnzLDNkuLj113ebzTJT22MH2JpKclbrtc0lWzOW4qSd/Mfy6V9JJZbH+6pH7f4DVQHBgDQpKAK4GvRcQTI+IQslvNH1/iYU8HdgRGRLwmIvp9Z+oOEXFkProU6DowrHsOjMFxLPBgROzoyCYi7o6ID8CO/8t+XdLafDhy6g46rSPpLXmHPuslvUfSacAY8PG8s5c9JF0naSxf/4R8H+slfTn1P0LScZK+kx/rw5J2z+ffJen8fJ8bJB2Yz99P0hfz+R+SdLekJfmyTflu3wMck9d5ztQzB0lXSVqej79S0vclXQ8cVVhnP0lXSPp2PuxYZgX9vtXUQ9oAvBF4X4fli8ifeiR77mM8H19K/lBUh3VOBL4JLMqnR/Kf11F4MKo1DexH9vRqo7j+lHqWA1dNmbcw3+7J+fR/Amfn43cBb8jHXw9cko+vAs7Lx08g6y9iST69qd2xyM6MVhWmr8rXeQzZI+f7AbsB32itB3wCODof3x+4o9//5nUcdk1OFqsVSavJnld4MCIOBR4BrFLWPeE24MltNptunecCH4mILQARMbUzmKkOJ7s0mkhcv+UpwEREfD+fvgxYSfbAGMCa/OctwJ/l40cDp+THuVrSLxOP1c5hZD1f/RxA0qfZ+XfwtOzKD4C9Je0VERvncLyh48AYHLeTPRAGQESszE/Nx/NZ5wA/Aw4mu9T8TZt9TLeO2Lnnp5l0u35xu05+m//cxkN/m7PpeWorO19uLyyMT1f3LsAREfHALI43b7gNY3B8BVgo6XWFeYsK4/sA90bEdrInIhe02cd061wLvErSIgBJI/n8jcBebfZzI/AcSY0p68/ke8BSSX+QT7+crDevTm4g64AGSccD+7ZZZ2qddwHLJO0i6QlAq7Pgm4DlkkYlPYKsS4SWa4GzWhP5WZhN4cAYEJFdXJ9M9kGdkHQz2Sn9W/NVPgj8paRvkZ1mb26zm7brRMTVwGeBcUnryHoGA7gUuLjV6Fmo5efAmcAaSevJOq9t5zhJP2kNwDOAVwKXS9pA1nflxdNs23I+cLyktWRtLfeSBUTRrcDWvAH2HLK2iQlgA1lvXGvzuu8le/z9RuBLrfm5NwJjkm6V9F3gr2aoa17y4+1Wa/m3KNsiYqukI4B/iwj/379P3IZhdbc/8Jm8V7UHgTP6XM+85jMMM0vmNgwzS+bAMLNkDgwzS+bAMLNkDgwzS/b/NgOG4KXTyG0AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "mask_map *= mask_map_catalog\n",
    "mask_map.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create the mask from statistically significant pixels in a dataset\n",
    "\n",
    "Here we want to determine an exclusion from the data directly. We will estimate the significance of the data and exclude all pixels above a given threshold.\n",
    "\n",
    "Here we use a dataset taken from Fermi data used in the 3FHL catalog. The dataset is already in the form of a `Datasets` object. We read it from disk. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "datasets = Datasets.read(\n",
    "    \"$GAMMAPY_DATA/fermi-3fhl-crab/Fermi-LAT-3FHL_datasets.yaml\",\n",
    "    \"$GAMMAPY_DATA/fermi-3fhl-crab/Fermi-LAT-3FHL_models.yaml\",\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We want to compute the significance per pixels for the data integrated over energy. We reduce the dataset to a simple image. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = datasets[0].to_image()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now apply a significance estimation. We integrate the counts using a correlation radius of 0.4 degree and apply regular significance estimate. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "estimator = ExcessMapEstimator(\"0.4 deg\")\n",
    "result = estimator.run(dataset, steps=\"ts\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we copy the significance map for our mask and apply a threshold of 5 sigma to remove pixels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "mask_map_significance = result[\"significance\"].copy()\n",
    "mask_map_significance.data = mask_map_significance.data < 5.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<Figure size 432x288 with 1 Axes>,\n",
       " <matplotlib.axes._subplots.WCSAxesSubplot at 0x11d254dd8>,\n",
       " None)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUMAAAEHCAYAAAA0+iR9AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAATe0lEQVR4nO3debCddX3H8fcHUELCUpPQTYUcpyraFlGCC24MWhVqp1JsG+3YUltsFXXQsW5d1U5rVaq2YHF01LgrhbEtVbStBRdwiSkQrY62XnHBEXtxCQHEJN/+cZ4DJ5dzzz333pzn3HPzfs08c5/1PN9fbvLJs/5OqgpJOtAdNOkCJGklMAwliSkPwyS7Jl3DuKzWttmu6bOa29ZvqsNQkvYXw1CSgEzb3eQNGzbs7XQ6AZiZmaHT6Uy6pLFYrW2zXdNnNbVtZmamZmdnBx4EHtJ2McvV6XSybdu2SZchaQpt3rw58y3zNFmSMAwlCTAMJQkwDCUJMAwlCTAMJQmYQBgmOSnJniRP7pu3Jcn2JOe2XY8kQcthmORg4G+AD89ZtAU4CXhoksPbrEmSoP0jw+cAFwM3zJnfexCy+sYlqTWthWGSuwNnABcOWHwJsA3YVlU726pJknrafB3vdcCLqmpPsu/BX1VtBba2WIsk7WOsYZjkHODsZvIo4L1NEG4ETk+yu6o+MMLn3N6f2vr168dRqqQDwMzMzD55UlXreuNjDcOqugC4YO78JG8DLh0lCJvPub3gzZs3T1c3O5JWjE6nw+zs7LpBy3zOUJKYUBdeVXXWJPYrSfPxyFCSMAwlCTAMJQkwDCUJMAwlCTAMJQkwDCUJMAwlCTAMJQkwDCUJMAwlCTAMJQkwDCUJMAwlCTAMJQkwDCUJMAwlCTAMJQkwDCUJMAwlCTAMJQkwDCUJMAwlCTAMJQkwDCUJMAwlCTAMJQkwDCUJMAwlCTAMJQkwDCUJMAwlCTAMJQkwDCUJMAwlCTAMJQkwDCUJMAwlCYBDJl2A1C/JneZV1QQq0YHGI0NJwjCUJMAwlCTAMJQkwBsoasGgmyLj2t6bLVoqjwwlCcNQkoAWwzDJKUl+kOTqZvizvmVbkmxPcm5b9UhSv7avGX68qp44YP4W4CTgXUkOr6qbWq5L0gFupdxA6V0hr75xTZnl3ihZCTV4A+bA1fY1w4cluSbJh5L8fN/8S4BtwLaq2tlyTZJE2vqfMMmRwN6quinJ6cDrq+reI267qze+fv36tbOzs+MqU8uwEo4Ml8sjw9Vtw4YN3HjjjTf3pqtqXW98pCPDJMcmeWwzfliSI0bc7pzeDRPg9muBVfVB4C5JNo7yOVW1rjd0Op1RNpGkO+l0OvvkSf+yBcMwydnAPwJvbGbdA/jAKDuuqguq6oSqOgHYm+bQIcmDm317iCdpRRjlBso5wIOBTwNU1VeS/OQS9vVk4JlJdgO3AFvKcxJJK8QoYfijqrqtdz0oySF07/ouSlWdD5y/2O2kNs133dP/t1e/Ua4ZXpHkpcBhSX4JuAj4l/GWJUntGiUMXwx8F9gB/AHwQeBPxlmUJLVtwdPkqtoLvKkZJGlVmjcMk+xgyLXBqjp+LBVJ0gQMOzLsvUN8TvPzHc3P3wJuvvPqOpCshgesF8M+FVe/ecOwqq4DSPLwqnp436IXJ/kk8PJxFydJbRnlBsq6JI/oTSQ5GVg3ZH1JmjqjPGf4e8BbkhzVTH8fePr4SpKk9o1yN/lzwAOajhZSVT8Yf1mS1K4Fw7C/R+pmGoCq8pqhpFVjlNPkXX3ja+jeZf7ieMqRpt+gO8/eYV75RjlNPq9/OslrgH8eW0WSNAFL6el6LXCv/V2IJE3SKNcM+99EORg4GnjFOIuSpLaNcs2w/9vsdgPfqardY6pHkiZilNPkv6yq65rhW1W1O8k7Ft5MUk+SgYNWjlHCsP9b7Hqdu544nnIkaTLmDcMkL0myEzg+yQ+bYSfwHeCfWqtQklowbxhW1V9X1RHAq6vqyGY4oqo2VNVLWqxRksZuWH+Gx1XVl4CLkjxo7vKq2j7WyiSpRcPuJj8feAZw3oBlBZw6lookaQKG9Wf4jGb0tKq6tX9ZkjVjrUorhnc8daAY5W7ylSPOk6SpNeya4U8Dd6f7FaEPBHqHCEfSfSVPklaNYdcMHw+cBdwD+Nu++TuBl46xJklq3bBrhluBrUnOrKqLW6xJklo3ShdeFyf5Zbpvoqzpm2/nrquMN0t0IFvwBkqSC4HfBJ5D97rhrwPHjrkuSWrVKHeTT66q3wa+V1UvAx4G3HO8ZUlSu0YJw1uanzcn+Vngx0BnfCVJUvtG6c/w0iQ/Abwa2E737ZM3jbUqSWrZKDdQer1aX5zkUro3UY4ba1WS1LJFfQdKVf2o+d7ki8ZUjyRNxFK+EArueBtFklaFpYahXwIraVUZ9m7yvzA49AJsGFtFkjQBw26gvGaJyyRp6gx7N/mKNgtRu3z1TtrXUq8ZStKqYhhKEoahJAGj9Vrzb83reL3puyX58HjLkqR2jfJu8saq+n5voqq+l+Qnx1iTWlB156emvKmiA9kop8l7kxzTm0hyLD50LWmVGeXI8I+BTyTpPWrzKLrfpyxJq8aCR4ZVdRnwIOB9wPuBE6tqSdcMk5yS5OokX+gLV5JsSbI9yblL+VxJWq5hr+MdV1VfSvKgZtb1zc9jkhxTVdsXs6PmJswbgCdU1dfnXHfcApwEvCvJ4VV102I+W5KWa9hp8vPpng6fN2BZAacucl9PBS6pqq8DVNUNfct6V+4Le8SRNAHDXsfrXRc8rapu7V+WZM2ATRZyH+AuSS4HjgBeX1Vvb5ZdAmwD3llVO5fw2Vok7xxL+xrlBsqVdK8ZLjRvlH2dCDwGOAy4KsmnqurLve9onm/DJLt64+vXr1/kbiWpa2ZmZp88qap1vfFh1wx/Grg7cFiSB3LH6euRwNpRdpzkHODsZvL9wGVVtQvYleRjwAOALy/0Of0Fb9682cd6JC1Jp9NhdnZ23aBlw44MHw+cBdyD7nXDXhj+EHjpKDuuqguACwCS3A84P8khwF2BhwCvHeVzJGnchl0z3ApsTXJmVV283B1V1ReTXAZcC+wF3lxVn1/u50rS/jDKGygnDng3+S+XsrOqenVV3b+qfqGqXreUz9D+UVV3GqQD2ShheNrcd5OB08dXkiS1b5QwPDjJob2JJIcBhw5ZX5KmziiP1rwT+I8kb6X7UPTTGfIYjCRNowXDsKpelWQH3ecDA7xiqe8mS9JKNcqRIVX1IeBDY65FkiZmlJ6uH5rks0luSnJbkj1JfthGcZLUllFuoJwPPAX4Ct3X6H4f+PtxFiVJbRv1NPl/khxcVXuAtya5csx1SVKrRgnDm5PcFbg6yauAbwMD3+2TpGk1ymny04CDgWcDu4B7AmeOsyhJatsoj9Zc14zeArxsvOVokvzGvPHxdceVb1gXXjsY8i14VXX8WCqSpAkYdmT4xNaqkKQJG9aF13XzLZOk1caHriUJH7qWJMCHrrWA+e6Cepd5ft45nk4+dC1JjP7Q9UH40LWkVWwxD13fig9dS1ql5j0yTPKrzfce96Y/neSrzfDkdsqTpHYMOzJ8IbClb/pQ4CS61wvfCvzjGOvSCrdaX93z5seBa1gY3rWqvtE3/YmqmgVmk3gDRdKqMuwGyt36J6rq2X2TR4+nHEmajGFh+OkkZ8+dmeQPgM+MryRJat+w0+TnAR9I8lRgezPvRLrXDp807sIkqU3DOmq4ATg5yanAzzez/7WqPtpKZZLUolGeM/woYABqQSv11T3vEGsUo7yBIkmrnmEoSRiGkgQYhpIEjNifobQc3sDQNPDIUJIwDCUJMAwlCTAMJQkwDCUJMAwlCTAMJQkwDCUJMAwlCTAMJQkwDCUJMAwlCWgxDJP8UZKrm+HzSfYkWd8s25Jke5Jz26pHkvq1FoZV9eqqOqGqTgBeAlxRVTc2i7fQ/YL6hyY5vK2aJKlnUqfJTwHe0zfd+5KM6huXpNa0HoZJ1gJPAC7um30JsA3YVlU7265JkibRueuvAJ/sO0WmqrYCWydQiyQBYw7DJOcAZzeTp1fV9XSvD75n/q0Gfs6u3vj69ev3X4GSDigzMzP75ElVreuNj/U0uaou6N00qarrkxwFPBr4p0V+zrre0Ol0xlOspFWv0+nskyf9y9q+ZngG8JGq2rXgmpLUolbDsKreVlVb2tynJI3CN1AkCcNQkgDDUJIAw1CSAMNQkgDDUJIAw1CSAMNQkgDDUJIAw1CSAMNQkgDDUJIAw1CSAMNQkgDDUJIAw1CSAMNQkgDDUJIAw1CSAMNQkgDDUJIAw1CSAMNQkgDDUJIAw1CSAMNQkgDDUJIAw1CSAMNQkgDDUJIAw1CSAMNQkgDDUJIAw1CSAMNQkgDDUJIAw1CSAMNQkgBIVU26hkXZuHFjbdq06fbpmZkZOp3O5AoaE9s1XWzXdJiZmanZ2dmBB4FTF4ZzJdlVVesmXcf+Zrumi+2afp4mSxKGoSQBq+A0WZL2B48MJQnDUJIAw1CSgBUahknekuSGJJ/vm3dCkk8luTrJtiQPbub/VjOvN+xNckKz7JRm3VdNqi39FtOuZtnxSa5K8oUkO5KsaeZPbbuSbEpyS9/v68K+baa2XX3Lj0lyU5IX9M2b2nYleXDf7+qaJGf0bbOi2rVsVbXiBuBRwIOAz/fN+whwWjN+OnD5gO1+Efhq3/T7gMOA84DjpqldwCHAtcADmukNwMGroF2b+teb8zlT266+5RcDFwEvWA3tAtYChzTjPwPc0De9otq13GFFHhlW1ceAG+fOBo5sxo8Crh+w6VOA9/RNH9RstxfIfi5z0RbZrscB11bVNc22s1W1p1k2ze0aZqrbleRJwFeBL8zZZmrbVVU3V9XuZv6aZr2eFdWuZZt0Gg/532sT+/7PdT/g68A3gG8Bxw7Y5n+BX+ibfjywHThv0u1ZbLuAc4F3AB9u2vDCVdKuTcAu4L+AK4BHrpJ2rQOuAg4H/oJ9jwyntl3NsofQDfibgDNWcruW9Wcy6QIW8cv6O+DMZvw3gH+fs/5DgB2Trnt/tQt4ATADbKR7qnIV8JhJ178f2nUosKEZP7H5x3fkpOvfD+16DfAbzfg+YbgSh8X++2rm3w/4DLBm0vWP5c9k0gUs4pf1A+54SDzAD+es/1rgpZOue3+1C9gCvK1vvT8F/mjS9e+v31ffepcDmydd/374fX0c+FozfJ/uaeizJ13/GH5f/7mSf1/LGVbkNcN5XA88uhk/FfhKb0GSg4BfB947gbqWa752fRg4PsnaJIc06/z3BOpbqoHtSnJ0koOb8XsB96Z7nW1aDGxXVT2yqjZV1SbgdcBfVdX5kylxSeb7fXWav38kORa4L93AX3UOmXQBgyR5D3AKsDHJN4E/B84GXt/8Ym4FntG3yaOAb1bViv5HtZh2VdX3kvwt8Fm6F6k/WFX/OpHCF7DI39ejgJcn2Q3sAf6wquZezF8RlvD3cCossl2PAF6c5Md0b5Q8q6r+r/2qx893kyWJFfrQtSS1zTCUJAxDSQIMQ0kCDENJAgxDSQIMQ80jyU8leXeSryb5XNOV2BkLbLOpv1uoRe7vrCQ/2zf95iT3H3HbU5JcupT9jirJlc3PTUmeuoTtz0oyTQ9hH3AMQ91JkgAfAD5WVfeqqhPpvh54jzHu9izg9jCsqt+vqhXzxk1VndyMbgIWHYZa+QxDDXIqcFtV3d7xalVdV1V/D7cfHX08yfZmOHnuBwxbJ8kLm85qr0nyyiRPBjYD72o6ET0syeVJNjfrP6H5jGuS/MeojUjymCT/1ezrLUkObeZ/LcnLms/ckeS4Zv7RSf6tmf/GJNcl2dgsu6n52FcCj2zqfN7cI74klyY5pRn/3SRfTnIF8PC+dY5OcnGSzzbD7cs0QZN+Odph5Q3Ac4HXDlm+lqbnErrvFm9rxjfRvPw/ZJ3TgCuBtc30+ubn5fR1ANCbBo6m27NNp3/9OfWcAlw6Z96aZrv7NNNvB85txr8GPKcZfxbw5mb8fOAlzfgT6L4GubGZvmnQvuge0Z7fN31ps87P0O0S62jgrsAne+sB7wYe0YwfA3xx0r9zh1qZ7yZrZUlyAd13VG+rqpOAuwDnp/v1CnuA+wzYbL51Hgu8tapuBqiF30t+KN3T9ZkR1++5LzBTVV9uprcC59DtRAHgkubn54Bfa8YfAZzR7OeyJN8bcV+DPIRub9HfBUjyPvb9M7h/92oEAEcmOaKqdi5jf1omw1CDfAE4szdRVec0p4vbmlnPA74DPIDupZZbB3zGfOuEfXtLXshi1+/fbpgfNT/3cMe/g6X01rybfS83rekbn6/ug4CHVdUtS9ifxsRrhhrko8CaJM/sm7e2b/wo4NtVtRd4GnDwgM+Yb52PAE9PshYgyfpm/k7giAGfcxXw6CSdOesv5EvApiQ/10w/jW7P2sN8gm7HpiR5HHC3AevMrfNrwAlJDkpyT6D3BVGfBk5JsiHJXeh2MdfzEeDZvYnm6FkTZhjqTqp7MetJdENoJsln6J5mvqhZ5Q3A7yT5FN1Tv10DPmbgOlV1GfDPwLYkV9Pt0RvgbcCFvRsofbV8l253UpckuYbulxAN8pgk3+wNwAOB3wUuSrKDbvdTF86zbc/LgMcl2U732ua36YZfv2uB3c3NnOfRvRY4A+yg29v19qbub9Pt8foq4N978xvPBTYnuTbJfwN/uEBdaoFdeEmN5m7znqraneRhwD9UlUdtBwivGUp3OAZ4f7o9p99Gt8NTHSA8MpQkvGYoSYBhKEmAYShJgGEoSYBhKEkA/D+StzGzk/2I9wAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "mask_map_significance.sum_over_axes().plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This method frequently yields isolated pixels or weakly significant features if one places the threshold too low. \n",
    "\n",
    "To overcome this issue, one can use `~skimage.filters.apply_hysteresis_threshold` . This filter allows to define two thresholds and mask only the pixels between the low and high thresholds if they are not continuously connected to a pixel above the high threshold. This allows to better preserve the structure of the excesses. \n",
    "\n",
    "Note that scikit-image is not a required dependency of gammapy, you might need to install it.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  },
  "nbsphinx": {
   "orphan": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}