02 - Generate an interferogram using SNAP.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "## 02 - Generate and interferogram using SNAP"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Quick link\n",
    "\n",
    "* [Objective](#Objective)\n",
    "* [Data](#Data)\n",
    "* [Workflow](#Workflow)\n",
    "  * [Orbit file correction](#Apply-orbit-file-SNAP-Operator)\n",
    "  * [TOPSAR split](#TOPSAR-split-SNAP-Operator)\n",
    "  * [Back-Geocoding](#Back-Geocoding-SNAP-Operator)\n",
    "  * [Interferogram](#Interferogram-SNAP-Operator)\n",
    "  * [TOPSAR Deburst](#TOPSAR-Deburst-SNAP-Operator)\n",
    "  * [TOPSAR Merge](#TOPSAR-Merge-SNAP-Operator)\n",
    "  * [TopoPhaseRemoval](#TopoPhaseRemoval-SNAP-Operator)\n",
    "  * [GoldsteinPhaseFiltering](#GoldsteinPhaseFiltering-SNAP-Operator)\n",
    "  * [Terrain correction](#Terrain-correction-SNAP-Operator)\n",
    "* [Note](#Note)\n",
    "* [Way forward](#Way-forward) \n",
    "* [License](#License)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Objective \n",
    "\n",
    "First stage-in the coseismic interferometric pair discovered in the previous lesson.\n",
    "\n",
    "Then use the SNAP Toolbox operators with Python to create a workflow that applies the SNAP Operators:\n",
    "\n",
    "- Orbit file correction\n",
    "- TOPSAR split\n",
    "- Back-Geocoding\n",
    "- Interferogram\n",
    "- TOPSAR Deburst\n",
    "- TOPSAR Merge\n",
    "- TopoPhaseRemoval\n",
    "- GoldsteinPhaseFiltering\n",
    "- Terrain correction\n",
    "\n",
    "This is just an example of a processing workflow using SNAP Operators. Potentially all SNAP graphs can be performed with this approach."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "SENTINEL data products are made available systematically and free of charge to all data users including the general public, scientific and commercial users. Radar data will be delivered within an hour of reception for Near Real-Time (NRT) emergency response, within three hours for NRT priority areas and within 24 hours for systematically archived data.\n",
    "\n",
    "All data products are distributed in the SENTINEL Standard Archive Format for Europe (SAFE) format.\n",
    "\n",
    "Data products are available in single polarisation (VV or HH) for Wave mode and dual polarisation (VV+VH or HH+HV) and single polarisation (HH or VV) for SM, IW and EW modes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will use the slave discovered in the previous lesson:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "slave_product = {'enclosure': 'https://store.terradue.com/download/sentinel1/files/v1/S1A_IW_SLC__1SDV_20161018T163206_20161018T163233_013547_015AEB_712A',\n",
    " 'identifier': 'S1A_IW_SLC__1SDV_20161018T163206_20161018T163233_013547_015AEB_712A',\n",
    " 'productType': 'SLC',\n",
    " 'self': 'https://catalog.terradue.com/sentinel1/search?format=atom&uid=S1A_IW_SLC__1SDV_20161018T163206_20161018T163233_013547_015AEB_712A',\n",
    " 'startdate': '2016-10-18T16:32:06.0438950Z',\n",
    " 'track': '175',\n",
    " 'wkt': 'POLYGON((19.368031 40.835575,22.396507 41.235806,22.733843 39.616779,19.779461 39.21563,19.368031 40.835575))'}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "master_product = {'enclosure': 'https://store.terradue.com/download/sentinel1/files/v1/S1A_IW_SLC__1SDV_20161006T163206_20161006T163233_013372_01554F_7FE0',\n",
    " 'identifier': 'S1A_IW_SLC__1SDV_20161006T163206_20161006T163233_013372_01554F_7FE0',\n",
    " 'self': 'https://catalog.terradue.com/sentinel1/search?format=atom&uid=S1A_IW_SLC__1SDV_20161006T163206_20161006T163233_013372_01554F_7FE0',\n",
    " 'startdate': '2016-10-06T16:32:06.0564920Z',\n",
    " 'track': '175',\n",
    " 'wkt': 'POLYGON((19.367752 40.834766,22.396078 41.234989,22.733395 39.616081,19.77915 39.214939,19.367752 40.834766))'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Workflow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Import the packages required for processing the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "from snappy import jpy\n",
    "from snappy import ProductIO\n",
    "from snappy import GPF\n",
    "from snappy import HashMap\n",
    "\n",
    "import dateutil.parser as parser\n",
    "import gc\n",
    "from datetime import datetime\n",
    "\n",
    "import cioppy\n",
    "\n",
    "import gdal\n",
    "import osr\n",
    "\n",
    "from shapely.wkt import loads\n",
    "from shapely.geometry import box\n",
    "\n",
    "import lxml.etree as etree\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Stage-in the slave and the master**\n",
    "\n",
    "Define where the data is staged-in. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "data_path = '/data2'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Stage-in the products"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "for product in [slave_product, master_product]:\n",
    "    \n",
    "    local_products = []\n",
    "    \n",
    "    local_path = os.path.join(data_path, product['identifier'])\n",
    "    if not (os.path.isdir(local_path)):\n",
    "        retrieved = ciop.copy(product['enclosure'], data_path)\n",
    "    else: \n",
    "        retrieved = local_path\n",
    "        \n",
    "    local_products.append(retrieved)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Read the products"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "s1meta = \"manifest.safe\"\n",
    "\n",
    "for index, s1path in enumerate([slave_product['identifier'], master_product['identifier']]):\n",
    "\n",
    "    s1prd= \"%s/%s/%s.SAFE/%s\" % (data_path, s1path, s1path, s1meta)\n",
    "    reader = ProductIO.getProductReader(\"SENTINEL-1\")\n",
    "    \n",
    "    if index == 0:\n",
    "        slave = reader.readProductNodes(s1prd, None)\n",
    "        slave_date = parser.parse(slave.getStartTime().toString()).isoformat()[:19]\n",
    "    else:\n",
    "        master = reader.readProductNodes(s1prd, None)\n",
    "        master_date = parser.parse(slave.getStartTime().toString()).isoformat()[:19]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Apply orbit file SNAP Operator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The orbit state vectors provided in the metadata of a SAR product are generally not accurate and can be refined with the precise orbit files which are available days-to-weeks after the generation of the product. \n",
    "\n",
    "The orbit file provides accurate satellite position and velocity information. Based on this information, the orbit state vectors in the abstract metadata of the product are updated."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List the parameters of the **Apply orbit file** SNAP Operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('orbitType', 'Sentinel Precise (Auto Download)')\n",
      "('polyDegree', '3')\n",
      "('continueOnFail', 'false')\n"
     ]
    }
   ],
   "source": [
    "operator = 'Apply-Orbit-File'\n",
    "\n",
    "op_spi = GPF.getDefaultInstance().getOperatorSpiRegistry().getOperatorSpi(operator)\n",
    "\n",
    "op_params = op_spi.getOperatorDescriptor().getParameterDescriptors()\n",
    "\n",
    "for param in op_params:\n",
    "    print(param.getName(), param.getDefaultValue())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apply the operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "parameters = HashMap()\n",
    "\n",
    "parameters.put('orbitType', 'Sentinel Precise (Auto Download)')\n",
    "parameters.put('polyDegree', '3')\n",
    "parameters.put('continueOnFail', 'false')\n",
    "\n",
    "\n",
    "master_orbit = GPF.createProduct(operator,\n",
    "                                 parameters, \n",
    "                                 master)\n",
    "    \n",
    "slave_orbit = GPF.createProduct(operator,\n",
    "                                 parameters, \n",
    "                                 slave)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TOPSAR split SNAP Operator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The TOPSAR Split operator provides a convenient way to split each subswath with selected bursts into a separate product. This operator is the first processing step in the TOPS InSAR processing chain.\n",
    "\n",
    "List the parameters of the **TOPSAR-Split** SNAP Operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('subswath', None)\n",
      "('selectedPolarisations', None)\n",
      "('firstBurstIndex', '1')\n",
      "('lastBurstIndex', '9999')\n",
      "('wktAoi', None)\n"
     ]
    }
   ],
   "source": [
    "operator = 'TOPSAR-Split'\n",
    "\n",
    "op_spi = GPF.getDefaultInstance().getOperatorSpiRegistry().getOperatorSpi(operator)\n",
    "\n",
    "op_params = op_spi.getOperatorDescriptor().getParameterDescriptors()\n",
    "\n",
    "for param in op_params:\n",
    "    print(param.getName(), param.getDefaultValue())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apply the operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "slave_split_prds = []\n",
    "master_split_prds = []\n",
    "\n",
    "for subswath in ['IW1', 'IW2', 'IW3']:  \n",
    "    \n",
    "    parameters = HashMap()\n",
    "\n",
    "    parameters.put('subswath', subswath)\n",
    "    parameters.put('selectedPolarisations', 'VV')\n",
    "    parameters.put('firstBurstIndex', '1')\n",
    "    parameters.put('lastBurstIndex', '9999')\n",
    "\n",
    "    master_split_prds.append(GPF.createProduct(operator,\n",
    "                           parameters, \n",
    "                           master_orbit))   \n",
    "    \n",
    "    slave_split_prds.append(GPF.createProduct(operator,\n",
    "                           parameters, \n",
    "                           slave_orbit))   \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Back-Geocoding SNAP Operator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This operator co-registers two S-1 SLC split products (master and slave) of the same sub-swath using the orbits of the two products and a Digital Elevation Model (DEM). \n",
    "\n",
    "In resampling the slave images into master frame, deramp and demodulation are performed first to the slave image, then the truncated-sinc interpolation is performed. Finally, the reramp and remodulation are applied to the interpolated slave image.\n",
    "\n",
    "List the parameters of the **Back-Geocoding** SNAP Operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('demName', 'SRTM 3Sec')\n",
      "('demResamplingMethod', 'BICUBIC_INTERPOLATION')\n",
      "('externalDEMFile', None)\n",
      "('externalDEMNoDataValue', '0')\n",
      "('resamplingType', 'BISINC_5_POINT_INTERPOLATION')\n",
      "('maskOutAreaWithoutElevation', 'true')\n",
      "('outputRangeAzimuthOffset', 'false')\n",
      "('outputDerampDemodPhase', 'false')\n",
      "('disableReramp', 'false')\n"
     ]
    }
   ],
   "source": [
    "operator = 'Back-Geocoding'\n",
    "\n",
    "op_spi = GPF.getDefaultInstance().getOperatorSpiRegistry().getOperatorSpi(operator)\n",
    "\n",
    "op_params = op_spi.getOperatorDescriptor().getParameterDescriptors()\n",
    "\n",
    "for param in op_params:\n",
    "    print(param.getName(), param.getDefaultValue())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apply the operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "backgeo_prds = []\n",
    "\n",
    "for index, subswath in enumerate(['IW1', 'IW2', 'IW3']):  \n",
    "    \n",
    "\n",
    "    parameters = HashMap()\n",
    "\n",
    "    for param in op_params:\n",
    "        parameters.put(param.getName(), param.getDefaultValue())\n",
    "\n",
    "\n",
    "    backgeo_prds.append(GPF.createProduct(operator,\n",
    "                           parameters, \n",
    "                           [master_split_prds[index], \n",
    "                            slave_split_prds[index]\n",
    "                           ]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interferogram SNAP Operator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This operator computes (complex) interferogram, with or without subtraction of the flat-earth (reference) phase. The reference phase is subtracted using a 2d-polynomial that is also estimated in this operator.\n",
    "\n",
    "If the orbits for interferometric pair are known, the flat-earth phase is estimated using the orbital and metadata information and subtracted from the complex interferogram. The flat-earth phase is the phase present in the interferometric signal due to the curvature of the reference surface. The geometric reference system of the reference surface is defined by the reference system of satellite orbits (for now only WGS84 supported, which the reference system used by all space-borne SAR systems).\n",
    "\n",
    "The flat-earth phase is computed in a number of points distributed over the total image, after which a 2d-polynomial is estimated (using least squares) fitting these 'observations', (e.g. plane can be fitted by setting the degree to 1.)\n",
    "\n",
    "A polynomial of degree 5 normally is sufficient to model the reference phase for a full SAR scene (approx 100x100km). While, a lower degree might be selected for smaller images, and higher degree for 'long-swath' scenes. Note that the higher order terms of the flat-earth polynomial are usually small, because the polynomial describes a smooth, long wave body (ellipsoid). To recommended polynomial degree, that should ensure the smooth surface for most image sizes and areas of the world is 5th degree.\n",
    "\n",
    "List the parameters of the **Interferogram** SNAP Operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('subtractFlatEarthPhase', 'true')\n",
      "('srpPolynomialDegree', '5')\n",
      "('srpNumberPoints', '501')\n",
      "('orbitDegree', '3')\n",
      "('includeCoherence', 'true')\n",
      "('cohWinAz', '10')\n",
      "('cohWinRg', '10')\n",
      "('squarePixel', 'true')\n",
      "('subtractTopographicPhase', 'false')\n",
      "('demName', 'SRTM 3Sec')\n",
      "('externalDEMFile', None)\n",
      "('externalDEMNoDataValue', '0')\n",
      "('externalDEMApplyEGM', 'true')\n",
      "('tileExtensionPercent', '100')\n",
      "('outputElevation', 'false')\n",
      "('outputLatLon', 'false')\n"
     ]
    }
   ],
   "source": [
    "operator = 'Interferogram'\n",
    "\n",
    "op_spi = GPF.getDefaultInstance().getOperatorSpiRegistry().getOperatorSpi(operator)\n",
    "\n",
    "op_params = op_spi.getOperatorDescriptor().getParameterDescriptors()\n",
    "\n",
    "parameters = HashMap()\n",
    "\n",
    "for param in op_params:\n",
    "    print(param.getName(), param.getDefaultValue())\n",
    "    parameters.put(param.getName(), param.getDefaultValue())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apply the operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "interferogram_prds = []\n",
    "\n",
    "for index, subswath in enumerate(['IW1', 'IW2', 'IW3']):  \n",
    "    \n",
    "    parameters = HashMap()\n",
    "\n",
    "    for param in op_params:\n",
    "        parameters.put(param.getName(), param.getDefaultValue())\n",
    "\n",
    "    interferogram_prds.append(GPF.createProduct(operator,\n",
    "                           parameters, \n",
    "                           backgeo_prds[index]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### TOPSAR Deburst SNAP Operator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the TOPSAR IW and EW SLC products, each product consists of one image per swath per polarization. IW products have 3 swaths and EW have 5 swaths. Each sub-swath image consists of a series of bursts, where each burst was processed as a separate SLC image. The individually focused complex burst images are included, in azimuth-time order, into a single subswath image, with black-fill demarcation in between, similar to the ENVISAT ASAR Wide ScanSAR SLC products.  \n",
    "\n",
    "For IW, a focused burst has a duration of 2.75 sec and a burst overlap of ~50-100 samples. For EW, a focused burst has a duration of 3.19 sec. Overlap increases in range within a sub- swath.  \n",
    "\n",
    "Images for all bursts in all sub-swaths of an IW SLC product are re-sampled to a common pixel spacing grid in range and azimuth.  Burst synchronisation is ensured for both IW and EW products.  \n",
    "\n",
    "List the parameters of the **TOPSAR Deburst** SNAP Operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('selectedPolarisations', None)\n"
     ]
    }
   ],
   "source": [
    "operator = 'TOPSAR-Deburst'\n",
    "\n",
    "op_spi = GPF.getDefaultInstance().getOperatorSpiRegistry().getOperatorSpi(operator)\n",
    "\n",
    "op_params = op_spi.getOperatorDescriptor().getParameterDescriptors()\n",
    "\n",
    "for param in op_params:\n",
    "    print(param.getName(), param.getDefaultValue())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apply the operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "deburst_prds = []\n",
    "\n",
    "for index, subswath in enumerate(['IW1', 'IW2', 'IW3']):  \n",
    " \n",
    "    parameters = HashMap()\n",
    "    parameters.put('selectedPolarisations', 'VV')\n",
    "\n",
    "    deburst_prds.append(GPF.createProduct(operator,\n",
    "                           parameters, \n",
    "                           interferogram_prds[index]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### TOPSAR Merge SNAP Operator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the TOPSAR IW and EW SLC products, each product consists of one image per swath per polarization. IW products have 3 swaths and EW have 5 swaths. Each sub-swath image consists of a series of bursts, where each burst was processed as a separate SLC image. The individually focused complex burst images are included, in azimuth-time order, into a single sub-swath image, with black-fill demarcation in between, similar to the ENVISAT ASAR Wide ScanSAR SLC products\n",
    "\n",
    "List the parameters of the **TOPSAR Merge** SNAP Operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('selectedPolarisations', None)\n"
     ]
    }
   ],
   "source": [
    "operator = 'TOPSAR-Merge'\n",
    "\n",
    "op_spi = GPF.getDefaultInstance().getOperatorSpiRegistry().getOperatorSpi(operator)\n",
    "\n",
    "op_params = op_spi.getOperatorDescriptor().getParameterDescriptors()\n",
    "\n",
    "for param in op_params:\n",
    "    print(param.getName(), param.getDefaultValue())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apply the operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "parameters = HashMap()\n",
    "parameters.put('selectedPolarisations', 'VV')\n",
    "\n",
    "tops_merge = GPF.createProduct(operator,\n",
    "                           parameters, \n",
    "                           deburst_prds)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### TopoPhaseRemoval SNAP Operator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This operator estimates and subtracts topographic phase from the interferogram. More specifically, this operator first \"radarcodes\" the Digital Elevation Model (DEM) of the area of interferogram, and then subtracts it from the complex interferogram.\n",
    "\n",
    "This operator has to be performed after the interferogram generation. It also requires an input DEM, SRTM can be used, or any other supported DEM. The DEM handling for most of elevation models, selection and download from internet of tiles covering the area of interest, interpolation, accounting for geoid undulation, etc, is performed automatically by the operator itself.\n",
    "\n",
    "List the parameters of the **TopoPhaseRemoval** SNAP Operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('orbitDegree', '3')\n",
      "('demName', 'SRTM 3Sec')\n",
      "('externalDEMFile', None)\n",
      "('externalDEMNoDataValue', '0')\n",
      "('tileExtensionPercent', '100')\n",
      "('outputTopoPhaseBand', 'false')\n",
      "('outputElevationBand', 'false')\n",
      "('outputLatLonBands', 'false')\n"
     ]
    }
   ],
   "source": [
    "operator = 'TopoPhaseRemoval'\n",
    "\n",
    "op_spi = GPF.getDefaultInstance().getOperatorSpiRegistry().getOperatorSpi(operator)\n",
    "\n",
    "op_params = op_spi.getOperatorDescriptor().getParameterDescriptors()\n",
    "\n",
    "for param in op_params:\n",
    "    print(param.getName(), param.getDefaultValue())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apply the operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "parameters = HashMap()\n",
    "\n",
    "for param in op_params:\n",
    "    parameters.put(param.getName(), param.getDefaultValue())\n",
    "\n",
    "\n",
    "topo_phase = GPF.createProduct(operator,\n",
    "                  parameters, \n",
    "                  tops_merge)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### GoldsteinPhaseFiltering SNAP Operator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Phase filtering is a preprocessing technique that greatly reduces the residues in the later on  phase unwrapping step and enhances the phase unwrapping accuracy. \n",
    "\n",
    "The method implemented in this operator is a nonlinear adaptive algorithm proposed by Goldstein and Werner [1] in 1998.\n",
    "\n",
    "List the parameters of the **GoldsteinPhaseFiltering** SNAP Operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('alpha', '1.0')\n",
      "('FFTSizeString', '64')\n",
      "('windowSizeString', '3')\n",
      "('useCoherenceMask', 'false')\n",
      "('coherenceThreshold', '0.2')\n"
     ]
    }
   ],
   "source": [
    "operator = 'GoldsteinPhaseFiltering'\n",
    "\n",
    "op_spi = GPF.getDefaultInstance().getOperatorSpiRegistry().getOperatorSpi(operator)\n",
    "\n",
    "op_params = op_spi.getOperatorDescriptor().getParameterDescriptors()\n",
    "\n",
    "for param in op_params:\n",
    "    print(param.getName(), param.getDefaultValue())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apply the operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "parameters = HashMap()\n",
    "\n",
    "for param in op_params:\n",
    "    parameters.put(param.getName(), param.getDefaultValue())\n",
    "\n",
    "\n",
    "goldstein = GPF.createProduct(operator,\n",
    "                  parameters, \n",
    "                  topo_phase)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Terrain correction SNAP Operator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Due to topographical variations of a scene and the tilt of the satellite sensor, distances can be distorted in the SAR images. Image data not directly at the sensor’s Nadir location will have some distortion. \n",
    "\n",
    "Terrain corrections are intended to compensate for these distortions so that the geometric representation of the image will be as close as possible to the real world.\n",
    "\n",
    "List the parameters of the **Terrain correction** SNAP Operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('sourceBandNames', None)\n",
      "('demName', 'SRTM 3Sec')\n",
      "('externalDEMFile', None)\n",
      "('externalDEMNoDataValue', '0')\n",
      "('externalDEMApplyEGM', 'true')\n",
      "('demResamplingMethod', 'BILINEAR_INTERPOLATION')\n",
      "('imgResamplingMethod', 'BILINEAR_INTERPOLATION')\n",
      "('pixelSpacingInMeter', '0')\n",
      "('pixelSpacingInDegree', '0')\n",
      "('mapProjection', 'WGS84(DD)')\n",
      "('alignToStandardGrid', 'false')\n",
      "('standardGridOriginX', '0')\n",
      "('standardGridOriginY', '0')\n",
      "('nodataValueAtSea', 'true')\n",
      "('saveDEM', 'false')\n",
      "('saveLatLon', 'false')\n",
      "('saveIncidenceAngleFromEllipsoid', 'false')\n",
      "('saveLocalIncidenceAngle', 'false')\n",
      "('saveProjectedLocalIncidenceAngle', 'false')\n",
      "('saveSelectedSourceBand', 'true')\n",
      "('outputComplex', 'false')\n",
      "('applyRadiometricNormalization', 'false')\n",
      "('saveSigmaNought', 'false')\n",
      "('saveGammaNought', 'false')\n",
      "('saveBetaNought', 'false')\n",
      "('incidenceAngleForSigma0', 'Use projected local incidence angle from DEM')\n",
      "('incidenceAngleForGamma0', 'Use projected local incidence angle from DEM')\n",
      "('auxFile', 'Latest Auxiliary File')\n",
      "('externalAuxFile', None)\n"
     ]
    }
   ],
   "source": [
    "operator = 'Terrain-Correction'\n",
    "\n",
    "op_spi = GPF.getDefaultInstance().getOperatorSpiRegistry().getOperatorSpi(operator)\n",
    "\n",
    "op_params = op_spi.getOperatorDescriptor().getParameterDescriptors()\n",
    "\n",
    "for param in op_params:\n",
    "    print(param.getName(), param.getDefaultValue())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apply the operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "parameters = HashMap()\n",
    "\n",
    "for param in op_params:\n",
    "    parameters.put(param.getName(), param.getDefaultValue())\n",
    "\n",
    "\n",
    "terrain = GPF.createProduct(operator,\n",
    "                  parameters, \n",
    "                  goldstein)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Write the result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ProductIO.writeProduct(terrain, \n",
    "                       'interferogram.tif',\n",
    "                       'GeoTIFF-BigTIFF')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Note\n",
    "\n",
    "This notebook computation is a long process and we suggest using the notebook interface for the development of the workflow up to the **Write the result** step.\n",
    "\n",
    "For its execution, we recommend using a shell to run:\n",
    "\n",
    "```bash\n",
    "jupyter nbconvert --ExecutePreprocessor.timeout=86400 --to notebook --execute '02 - Generate an interferogram using SNAP.ipynb' \n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Way forward"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The workflow above can of course be adapted to other SNAP Graphs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### License"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "This work is licenced under a [Attribution-ShareAlike 4.0 International License (CC BY-SA 4.0)](http://creativecommons.org/licenses/by-sa/4.0/) \n",
    "\n",
    "YOU ARE FREE TO:\n",
    "\n",
    "* Share - copy and redistribute the material in any medium or format.\n",
    "* Adapt - remix, transform, and built upon the material for any purpose, even commercially.\n",
    "\n",
    "UNDER THE FOLLOWING TERMS:\n",
    "\n",
    "* Attribution - You must give appropriate credit, provide a link to the license, and indicate if changes were made. You may do so in any reasonable manner, but not in any way that suggests the licensor endorses you or your use.\n",
    "* ShareAlike - If you remix, transform, or build upon the material, you must distribute your contributions under the same license as the original."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}