{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Compare Snow Depths with Interferogram\n",
    "\n",
    "**Goal**: Compare the insar phase to snowdepths\n",
    "\n",
    "**Approach**: \n",
    "1. Define an area to study the relationship \n",
    "2. Grab the snow depths from the magnaprobe in the area\n",
    "3. Grab the real and imaginary pixels nearest the magna probe locations \n",
    "4. Plot it\n",
    "\n",
    "\n",
    "### Step 1:  Define an Area to Compare Depths to Interferogram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/micah/projects/venv/snowexenv/lib/python3.8/site-packages/sqlalchemy/sql/functions.py:61: SAWarning: The GenericFunction 'st_pixelaspoint' is already registered and is going to be overridden.\n",
      "  util.warn(\n",
      "/home/micah/projects/venv/snowexenv/lib/python3.8/site-packages/sqlalchemy/sql/functions.py:61: SAWarning: The GenericFunction 'st_pixelaspoints' is already registered and is going to be overridden.\n",
      "  util.warn(\n",
      "/home/micah/projects/venv/snowexenv/lib/python3.8/site-packages/sqlalchemy/sql/functions.py:61: SAWarning: The GenericFunction 'st_rastertoworldcoord' is already registered and is going to be overridden.\n",
      "  util.warn(\n",
      "/home/micah/projects/venv/snowexenv/lib/python3.8/site-packages/sqlalchemy/sql/functions.py:61: SAWarning: The GenericFunction 'st_clip' is already registered and is going to be overridden.\n",
      "  util.warn(\n",
      "/home/micah/projects/venv/snowexenv/lib/python3.8/site-packages/sqlalchemy/sql/functions.py:61: SAWarning: The GenericFunction 'st_count' is already registered and is going to be overridden.\n",
      "  util.warn(\n"
     ]
    }
   ],
   "source": [
    "from snowexsql.data import PointData, ImageData, SiteData \n",
    "from snowexsql.db import get_db\n",
    "from snowexsql.conversions import points_to_geopandas, query_to_geopandas, raster_to_rasterio\n",
    "\n",
    "from snowexsql.functions import ST_PixelAsPoint\n",
    "import geoalchemy2.functions as gfunc\n",
    "from geoalchemy2.types import Raster\n",
    "from geoalchemy2.shape import to_shape, from_shape\n",
    "from datetime import date\n",
    "from sqlalchemy.sql import func\n",
    "import geopandas as gpd\n",
    "import numpy as np \n",
    "from rasterio.plot import show\n",
    "import matplotlib.pyplot as plt \n",
    "\n",
    "# PIT Site Identifier\n",
    "site_id = '5S31'\n",
    "\n",
    "# Distance around the pit to collect data in meters\n",
    "buffer_dist = 50\n",
    "\n",
    "# Connect to the database\n",
    "db_name = 'db.snowexdata.org/snowex'\n",
    "\n",
    "engine, session = get_db(db_name, credentials='./credentials.json')\n",
    "\n",
    "# Grab our pit location by provided site id from the site details table\n",
    "qry = session.query(SiteData.geom).filter(SiteData.site_id == site_id)\n",
    "sites = qry.all()\n",
    "\n",
    "# There can be different dates at a single site, so we only grab one to retrieve the geometry object\n",
    "point = sites[0][0]\n",
    "\n",
    "# Create a polygon buffered by our distance centered on the pit\n",
    "qry = session.query(gfunc.ST_Buffer(point, buffer_dist))\n",
    "buffered_pit = qry.all()[0][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 2: Grab all the Snow Depths in the Area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "114 Snow Depths found with 50m of 5S31\n"
     ]
    }
   ],
   "source": [
    "# Grab all the snow depths measured by a probe in the buffer\n",
    "qry = session.query(PointData).filter(gfunc.ST_Within(PointData.geom, buffered_pit))\n",
    "points = qry.filter(PointData.instrument.in_(['mesa','magnaprobe','pit ruler'])).all()\n",
    "\n",
    "# Convert the records received to geopandas\n",
    "df_points = points_to_geopandas(points)\n",
    "print('{} Snow Depths found with {}m of {}'.format(len(df_points.index), buffer_dist, site_id))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 3: Grab near polygons of pixels in the area"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loop over all the points\n",
    "session.rollback()\n",
    "\n",
    "def custom_query(session, poi, name, polarization, dem):\n",
    "    '''\n",
    "    Form a query to grab a value of a raster at a given point with \n",
    "    filtering on name of the data, uavsar polarization, and the dem used for \n",
    "    processing.\n",
    "    \n",
    "    Return the records (which should be only one)\n",
    "    '''\n",
    "    qry = session.query(ImageData.id, \n",
    "                  ImageData.type,\n",
    "                  func.ST_NearestValue(ImageData.raster, poi))\n",
    "    qry = qry.filter(ImageData.date == date(2020, 2, 12))\n",
    "    qry = qry.filter(ImageData.type.contains(name))\n",
    "    qry = qry.filter(ImageData.description.contains(polarization))\n",
    "    qry = qry.filter(ImageData.description.contains(dem))\n",
    "    qry = qry.filter(ImageData.site_name == 'Grand Mesa')\n",
    "    qry = qry.filter(gfunc.ST_Within(poi, func.ST_Envelope(ImageData.raster)))\n",
    "    return qry.all()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = gpd.GeoDataFrame(columns=['geom','depth','img','real','phase'])\n",
    "\n",
    "# loop over all our snow depths\n",
    "for i, row in df_points.iterrows():\n",
    "    # Form a EWKT geom object to find values\n",
    "    poi = from_shape(row['geom'], srid=26912).ST_AsEWKT()\n",
    "    \n",
    "    # Grab the nearest pixel value to our snow depth\n",
    "    img = custom_query(session, poi, 'interferogram imaginary', 'VV','DTM')\n",
    "    real = custom_query(session, poi, 'interferogram real', 'VV','DTM')\n",
    "    \n",
    "    # Store for later \n",
    "    results = {'img':img[-1][-1],\n",
    "               'real':real[-1][-1],\n",
    "               'geom': row['geom'],\n",
    "               'depth':row['value']}\n",
    "\n",
    "    # Add it to our df\n",
    "    df = df.append(results, ignore_index=True)\n",
    "\n",
    "    \n",
    "# Close the session to avoid hanging transactions\n",
    "session.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate the phase \n",
    "df['phase'] = np.arctan(df['img'] / df['real'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "tags": [
     "nbsphinx-thumbnail",
     "nbsphinx-gallery"
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1,1,figsize=(8,8))\n",
    "\n",
    "# Plot the comparison\n",
    "ax.plot(df['phase'], df['depth'], '.')\n",
    "\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}