From 2cae9073802279456b0176ba6eed97c9aa60d4e4 Mon Sep 17 00:00:00 2001 From: Manmeet Singh Date: Fri, 6 May 2022 20:14:15 +0530 Subject: [PATCH 01/14] Update multiple_subplots.py --- xarray_tutorial/multiple_subplots.py | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/xarray_tutorial/multiple_subplots.py b/xarray_tutorial/multiple_subplots.py index 252e873..975de9e 100644 --- a/xarray_tutorial/multiple_subplots.py +++ b/xarray_tutorial/multiple_subplots.py @@ -52,3 +52,12 @@ fig.patch.set_linewidth(10) fig.patch.set_edgecolor('cornflowerblue') + +left_ = 0.125 # the left side of the subplots of the figure +right_ = 0.9 # the right side of the subplots of the figure +bottom_ = 0.1 # the bottom of the subplots of the figure +top_ = 0.9 # the top of the subplots of the figure +wspace_ = 0.5 # the amount of width reserved for blank space between subplots +hspace_ = 0.1 # the amount of height reserved for white space between subplots + +plt.subplots_adjust(left=left_, bottom=bottom_, right=right_, top=top_, wspace=wspace_, hspace=hspace_) From cdbfaea38686cb9828a0ecc74fcb79164283ebe7 Mon Sep 17 00:00:00 2001 From: Manmeet Singh Date: Thu, 19 May 2022 09:49:32 -0500 Subject: [PATCH 02/14] Update README.md --- README.md | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/README.md b/README.md index c151726..ab97700 100644 --- a/README.md +++ b/README.md @@ -183,6 +183,13 @@ Now start the notebook by noting the link from NOTEBOOK_LOGFILE1 76. Copying to box using lftp mirror -R folder +77. Transforming argparse python code to jupyter notebook: https://stackoverflow.com/questions/37534440/passing-command-line-arguments-to-argv-in-jupyter-ipython-notebook + +Simply add the following lines: + +import sys +sys.argv = [''] + Troubleshooting 1. Continue in outer loop using multi-loops https://stackoverflow.com/questions/14829640/how-to-continue-in-nested-loops-in-python From e450ea015de0e229e826636bb22387f205ad19e2 Mon Sep 17 00:00:00 2001 From: Manmeet Singh Date: Sun, 22 May 2022 08:37:47 -0500 Subject: [PATCH 03/14] Update README.md --- README.md | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/README.md b/README.md index ab97700..c9623d9 100644 --- a/README.md +++ b/README.md @@ -190,6 +190,14 @@ Simply add the following lines: import sys sys.argv = [''] +78. Install pytorch with cuda + +https://stackoverflow.com/questions/58424974/anaconda-importerror-usr-lib64-libstdc-so-6-version-glibcxx-3-4-21-not-fo + +https://stackoverflow.com/questions/70340812/how-to-install-pytorch-with-cuda-support-with-pip-in-visual-studio + + + Troubleshooting 1. Continue in outer loop using multi-loops https://stackoverflow.com/questions/14829640/how-to-continue-in-nested-loops-in-python From 0233a23cb0ab6e8e131d5ebbc80e1136646810aa Mon Sep 17 00:00:00 2001 From: Manmeet Singh Date: Tue, 14 Jun 2022 13:47:27 +0530 Subject: [PATCH 04/14] Update README.md --- README.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/README.md b/README.md index c9623d9..e242ff2 100644 --- a/README.md +++ b/README.md @@ -196,7 +196,12 @@ https://stackoverflow.com/questions/58424974/anaconda-importerror-usr-lib64-libs https://stackoverflow.com/questions/70340812/how-to-install-pytorch-with-cuda-support-with-pip-in-visual-studio +79. Running docker containers on NVIDIA DGX A100 +$ docker pull nvcr.io/nvidia/tensorflow:20.10-tf2-py3 + +$ docker run --gpus all -it -v /home/cccr_rnd:/apollo nvcr.io/nvidia/tensorflow:20.10-tf2-py3 + Troubleshooting From f8b487ef40478acc25e9e3fde3ecb2a1616483d0 Mon Sep 17 00:00:00 2001 From: Manmeet Singh Date: Sat, 25 Jun 2022 02:10:03 -0500 Subject: [PATCH 05/14] Create extract_box_inner.py --- xarray_tutorial/extract_box_inner.py | 1 + 1 file changed, 1 insertion(+) create mode 100644 xarray_tutorial/extract_box_inner.py diff --git a/xarray_tutorial/extract_box_inner.py b/xarray_tutorial/extract_box_inner.py new file mode 100644 index 0000000..b0ecc00 --- /dev/null +++ b/xarray_tutorial/extract_box_inner.py @@ -0,0 +1 @@ +ds_o = ds.where((ds["lon"] < 60) | (ds["lon"] > 80), drop=True).where((ds["lat"] < 10) | (ds["lat"] > 20), drop=True) From ec2b266f31067944a075f16033359391e5949cc5 Mon Sep 17 00:00:00 2001 From: Manmeet Singh Date: Mon, 1 Aug 2022 03:07:39 -0500 Subject: [PATCH 06/14] Add files via upload --- download_data/NDUI.ipynb | 881 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 881 insertions(+) create mode 100644 download_data/NDUI.ipynb diff --git a/download_data/NDUI.ipynb b/download_data/NDUI.ipynb new file mode 100644 index 0000000..fcf5055 --- /dev/null +++ b/download_data/NDUI.ipynb @@ -0,0 +1,881 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "wpza3bOT5vF_" + }, + "outputs": [], + "source": [ + "from google.colab import auth\n", + "auth.authenticate_user()" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "1IoAuuA5ZofY", + "outputId": "ef23b208-a251-4f28-9d8d-572e8ea4859c" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Mounted at /content/drive\n" + ] + } + ], + "source": [ + "from google.colab import drive\n", + "drive.mount('/content/drive')" + ] + }, + { + "cell_type": "code", + "source": [ + "import ee, folium" + ], + "metadata": { + "id": "pZ4Tbq9xXzl3" + }, + "execution_count": 38, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "_A-0m2IF6Cm_", + "outputId": "48266533-ae7c-460d-8286-0af6b52b161c", + "scrolled": true + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "To authorize access needed by Earth Engine, open the following URL in a web browser and follow the instructions. If the web browser does not start automatically, please manually browse the URL below.\n", + "\n", + " https://code.earthengine.google.com/client-auth?scopes=https%3A//www.googleapis.com/auth/earthengine%20https%3A//www.googleapis.com/auth/devstorage.full_control&request_id=LIO8I84zfmXn1AeZBVNK-9CaAy7WL-EWgvCUwdlKhEM&tc=kKVhQKYb6WeBB5g8qMYY1QSoxPfcOQ1YBwIaBMXK0f4&cc=jzckmjT3Mpxbl0c6w407B5GmC8bLSYEgFhIAOrgvHuA\n", + "\n", + "The authorization workflow will generate a code, which you should paste in the box below.\n", + "Enter verification code: 4/1AdQt8qjll_G3IVfs5QPnN5X8yhJPrDqKrK6mMx0QKCEqkP6ZIMLZ3V4mXqo\n", + "\n", + "Successfully saved authorization token.\n" + ] + } + ], + "source": [ + "import ee\n", + "ee.Authenticate()\n", + "ee.Initialize()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "15zZ6W8-VMEC" + }, + "source": [ + "## 2.import necessary python-packets" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ZgVlXQKmA1YA", + "outputId": "c69dccbb-3aef-4f81-f967-7a687468d5f3" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Collecting geopandas\n", + " Downloading geopandas-0.10.2-py2.py3-none-any.whl (1.0 MB)\n", + "\u001b[K |████████████████████████████████| 1.0 MB 5.1 MB/s \n", + "\u001b[?25hCollecting fiona>=1.8\n", + " Downloading Fiona-1.8.21-cp37-cp37m-manylinux2014_x86_64.whl (16.7 MB)\n", + "\u001b[K |████████████████████████████████| 16.7 MB 362 kB/s \n", + "\u001b[?25hCollecting pyproj>=2.2.0\n", + " Downloading pyproj-3.2.1-cp37-cp37m-manylinux2010_x86_64.whl (6.3 MB)\n", + "\u001b[K |████████████████████████████████| 6.3 MB 38.7 MB/s \n", + "\u001b[?25hRequirement already satisfied: pandas>=0.25.0 in /usr/local/lib/python3.7/dist-packages (from geopandas) (1.3.5)\n", + "Requirement already satisfied: shapely>=1.6 in /usr/local/lib/python3.7/dist-packages (from geopandas) (1.8.2)\n", + "Requirement already satisfied: attrs>=17 in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas) (21.4.0)\n", + "Collecting munch\n", + " Downloading munch-2.5.0-py2.py3-none-any.whl (10 kB)\n", + "Requirement already satisfied: click>=4.0 in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas) (7.1.2)\n", + "Collecting click-plugins>=1.0\n", + " Downloading click_plugins-1.1.1-py2.py3-none-any.whl (7.5 kB)\n", + "Collecting cligj>=0.5\n", + " Downloading cligj-0.7.2-py3-none-any.whl (7.1 kB)\n", + "Requirement already satisfied: certifi in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas) (2022.6.15)\n", + "Requirement already satisfied: six>=1.7 in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas) (1.15.0)\n", + "Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas) (57.4.0)\n", + "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas>=0.25.0->geopandas) (2022.1)\n", + "Requirement already satisfied: python-dateutil>=2.7.3 in /usr/local/lib/python3.7/dist-packages (from pandas>=0.25.0->geopandas) (2.8.2)\n", + "Requirement already satisfied: numpy>=1.17.3 in /usr/local/lib/python3.7/dist-packages (from pandas>=0.25.0->geopandas) (1.21.6)\n", + "Installing collected packages: munch, cligj, click-plugins, pyproj, fiona, geopandas\n", + "Successfully installed click-plugins-1.1.1 cligj-0.7.2 fiona-1.8.21 geopandas-0.10.2 munch-2.5.0 pyproj-3.2.1\n", + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Collecting PyShp\n", + " Downloading pyshp-2.3.1-py2.py3-none-any.whl (46 kB)\n", + "\u001b[K |████████████████████████████████| 46 kB 2.5 MB/s \n", + "\u001b[?25hInstalling collected packages: PyShp\n", + "Successfully installed PyShp-2.3.1\n", + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Requirement already satisfied: gdal in /usr/local/lib/python3.7/dist-packages (2.2.2)\n" + ] + } + ], + "source": [ + "try:\n", + " import geopandas as gpd\n", + " import shapefile\n", + " from osgeo import ogr,osr,gdal\n", + "except:\n", + " !pip install geopandas\n", + " !pip install PyShp\n", + " !pip install gdal\n", + "import geopandas as gpd\n", + "import shapefile\n", + "import numpy as np\n", + "import os\n", + "import time\n", + "from osgeo import ogr,osr,gdal\n", + "import tensorflow as tf" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OZ9kd0IkVMEE" + }, + "source": [ + "## 3.Compute NDUI" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "ZkCbt6F1I1Yn" + }, + "outputs": [], + "source": [ + "F101992 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F101992').select('stable_lights')\n", + "F101993 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F101993').select('stable_lights')\n", + "F101994 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F101994').select('stable_lights')\n", + "F121994 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F121994').select('stable_lights')\n", + "F121995 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F121995').select('stable_lights')\n", + "F121996 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F121996').select('stable_lights')\n", + "F121997 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F121997').select('stable_lights')\n", + "F121998 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F121998').select('stable_lights')\n", + "F121999 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F121999').select('stable_lights')\n", + "F141997 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F141997').select('stable_lights')\n", + "F141998 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F141998').select('stable_lights')\n", + "F141999 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F141999').select('stable_lights')\n", + "F142000 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F142000').select('stable_lights')\n", + "F142001 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F142001').select('stable_lights')\n", + "F142002 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F142002').select('stable_lights')\n", + "F142003 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F142003').select('stable_lights')\n", + "F152000 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F152000').select('stable_lights')\n", + "F152001 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F152001').select('stable_lights')\n", + "F152002 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F152002').select('stable_lights')\n", + "F152003 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F152003').select('stable_lights')\n", + "F152004 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F152004').select('stable_lights')\n", + "F152005 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F152005').select('stable_lights')\n", + "F152006 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F152006').select('stable_lights')\n", + "F152007 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F152007').select('stable_lights')\n", + "F162004 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F162004').select('stable_lights')\n", + "F162005 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F162005').select('stable_lights')\n", + "F162006 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F162006').select('stable_lights')\n", + "F162007 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F162007').select('stable_lights')\n", + "F162008 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F162008').select('stable_lights')\n", + "F162009 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F162009').select('stable_lights')\n", + "F182010 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F182010').select('stable_lights')\n", + "F182011 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F182011').select('stable_lights')\n", + "F182012 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F182012').select('stable_lights')\n", + "\n", + "collections = [F101992, F101993, F101994, F121994, F121995, F121996, F121997, F121998, F121999, F141997, F141998, \n", + " F141999, F142000, F142001,F142002, F142003, F152000, F152001, F152002, F152003, F152004, F152005, \n", + " F152006, F152007,F162004, F162005, F162006, F162007, F162008, F162009, F182010, F182011, F182012]\n", + "\n", + "c = [-3.06516, -2.0638, -1.68421, -1.71621, 0.530922, 0.303469, -0.18513, 0.490138, 1.800988, -0.6186,\n", + " -0.91352, -1.37993, 0.061872, 0.249452, 1.127103, 0.866522,0, 0.005164,-0.04462, -0.27189, -0.06977, 0.449229,\n", + " 0.913485, 0.644785, -0.02563, -0.54115, -0.38377, 0.629564, 0.745403, -0.15161, 6.22332, 1.427157, 3.866698]\n", + " \n", + "b = [-0.00698, -0.00726, -0.00695, -0.00454, 0.00011, -0.00176, -0.00057, 0.001236, 0.002969, -0.0094, \n", + " -0.00929, -0.00889, -0.00469, -0.00452, -0.00221, -0.00351, 0, 8.94e-05, 0.000117, -0.0085, -0.00912, -0.00601,\n", + " -0.00595, -0.00675, -0.00496, -0.0094, -0.0061, -0.00084, -0.00062, -0.00278, 0.014627,0.002877, 0.007962]\n", + " \n", + "a = [1.519907, 1.516595, 1.491333, 1.331971, 0.984465, 1.111207, 1.034429, 0.905787, 0.761106, 1.603921,\n", + " 1.603648, 1.586457, 1.294471, 1.275902, 1.128708, 1.206319, 1, 1.002879, 0.987943, 1.555808, 1.591033, 1.401146, \n", + " 1.381139,1.448976, 1.317581, 1.613536, 1.41435, 1.040815, 1.037042, 1.193437, -0.08536, 0.774923, 0.355542]\n", + "\n", + "images = [0 for _ in range(33)]\n", + "count = 0\n", + "total_list = []\n", + "images_correct = [0 for _ in range(33)]\n", + "\n", + "def fun3(raw,correct):\n", + " out = correct.where(raw.lt(5.0),raw.float())\n", + " return out\n", + "\n", + "for i in range(33):\n", + " images[i] = ee.Image(a[i]).multiply(collections[i].float()).add(ee.Image(b[i]).multiply(collections[i].float().pow(2))).add(ee.Image(c[i]))\n", + " images_correct[i] = fun3(collections[i],images[i]).select('constant')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "tHS3XKhJI1WV" + }, + "outputs": [], + "source": [ + "China_city = ee.FeatureCollection('users/keithw0777/city_CN')\n", + "L7 = ee.ImageCollection('LE7_L1T_TOA').filterDate('2010-01-01', '2012-12-31')\n", + "OUTPUT_BUCKET='ndui_city' # define the storage bucket name \n", + "def fun4(img):\n", + " bad1 = img.select('B1').eq(0.0)\n", + " bad2 = img.select('B2').eq(0.0)\n", + " bad3 = img.select('B3').eq(0.0)\n", + " bad4 = img.select('B4').eq(0.0)\n", + " bad5 = img.select('B5').eq(0.0)\n", + " bad7 = img.select('B7').eq(0.0)\n", + " mask = img.mask().And(bad1.Or(bad2).Or(bad3).Or(bad4).Or(bad5).Or(bad7).Not())\n", + " #var mask = img.select('10','20','30','40','50','70').mask().reduce('product').eq(1);\n", + " masked = img.mask(mask);\n", + " ndvi = masked.normalizedDifference([\"B4\",\"B3\"])\n", + " return ndvi\n", + "\n", + "NDVIs = L7.map(fun4)\n", + "\n", + "Mean_NDVI = NDVIs.median()\n", + "Max_NDVI = NDVIs.max()\n", + "Min_NDVI = NDVIs.min()\n", + "mosaic = Mean_NDVI.where(Max_NDVI.gt(0.4), Max_NDVI)\n", + "mosaic = mosaic.where(Min_NDVI.lt(-0.2), Min_NDVI)\n", + "\n", + "F182012 = images_correct[32]\n", + "normalizeF182012 = F182012.toFloat().divide(63.0)\n", + "diff = normalizeF182012.add(mosaic.multiply(-1.0))\n", + "sum = normalizeF182012.add(mosaic)" + ] + }, + { + "cell_type": "code", + "source": [ + "ndui = diff.divide(sum)" + ], + "metadata": { + "id": "GgH0pVDKXFKd" + }, + "execution_count": 37, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "visualization = {\n", + " 'min': 0.0,\n", + " 'max': 1.0,\n", + " 'palette': ['black', 'blue', 'purple', 'cyan', 'green', 'yellow', 'red']\n", + " #'bands': ['B4', 'B3', 'B2'],\n", + "}\n", + "\n", + "map = folium.Map(location=[1.64, 110.20],zoom_start=4, height=1000,width=1500)\n", + "mapid = ndui.getMapId(visualization)\n", + "folium.TileLayer(\n", + " tiles=mapid['tile_fetcher'].url_format,\n", + " attr='Map Data © Google Earth Engine',\n", + " overlay=True,\n", + " name='Normalized Difference Urban Index',\n", + " opacity=0.5,\n", + " ).add_to(map)\n", + "\n", + "map.add_child(folium.LayerControl())\n", + "title_html = '''\n", + "

'NDUI'

\n", + " '''\n", + "map.get_root().html.add_child(folium.Element(title_html))\n", + "map" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "JgnvDn1zXgAc", + "outputId": "7bbb2650-4ab4-48bc-ad7e-85b3b26819a9" + }, + "execution_count": 61, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "
Make this Notebook Trusted to load map: File -> Trust Notebook
" + ] + }, + "metadata": {}, + "execution_count": 61 + } + ] + }, + { + "cell_type": "code", + "source": [ + "lat = 30.2672\n", + "lon = 360 - 97.7431\n", + "\n", + "\n", + "\n", + "\n", + "p = ee.Geometry.Point([lon, lat])\n", + "\n", + "data_b1 = ndui.reduceRegion(ee.Reducer.mean(),p,30).getInfo()" + ], + "metadata": { + "id": "lalVq9_Ua9kp" + }, + "execution_count": 64, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "data_b1" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "33e--AQ0bO9q", + "outputId": "72032794-4142-478c-e0f4-1237bd488faf" + }, + "execution_count": 65, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "{'constant': 0.889458586340854}" + ] + }, + "metadata": {}, + "execution_count": 65 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# China_city" + ], + "metadata": { + "id": "5cK1aShkPw_M" + }, + "execution_count": 42, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "id": "1dVJb9WMI1Rl" + }, + "outputs": [], + "source": [ + "# def filter_city_ndui(city):\n", + "# \"\"\"\n", + "# city:Guangzhou City\n", + "# \"\"\"\n", + "# city_shape = China_city.filter(ee.Filter.eq('city',city))\n", + "# ndui = diff.divide(sum).clip(city_shape)\n", + "# mask1 = Mean_NDVI.gt(0.0)\n", + "# mask2 = ndui.gt(0.0)\n", + "# ndui_mask = ndui.updateMask(mask1.And(mask2))\n", + "# # binary\n", + "# bin_mask = mask1.bitwiseAnd(mask2).clip(city_shape)\n", + "# return city_shape,ndui_mask,bin_mask" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "id": "N4p5aTqa2oOG" + }, + "outputs": [], + "source": [ + "# def export_task(image_mask,city_shape,file_name):\n", + "# task = ee.batch.Export.image.toDrive(\n", + "# image=image_mask,\n", + "# description='Training Export',\n", + "# fileNamePrefix=file_name,\n", + "# #bucket=OUTPUT_BUCKET,\n", + "# scale=30,\n", + "# region=city_shape.geometry())\n", + "# return task" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "id": "j092exl2Drs9" + }, + "outputs": [], + "source": [ + "# def found_file(file_name,OUTPUT_BUCKET='ndui_city'):\n", + "# #FILE_PATH = 'gs://' + OUTPUT_BUCKET + '/' + file_name+'.tif'\n", + "# FILE_PATH = 'drive/MyDrive/' + file_name+'.tif'\n", + "# print(FILE_PATH)\n", + "# print('Found training file.' if tf.io.gfile.exists(FILE_PATH) \n", + "# else 'No training file found.')" + ] + }, + { + "cell_type": "code", + "source": [ + "# !ls drive/MyDrive/ndui/Guangzhou_studyarea.shp" + ], + "metadata": { + "id": "Cdrd4pvqI61C" + }, + "execution_count": 46, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# city = gpd.read_file('drive/MyDrive/ndui/Guangzhou_studyarea.shp')" + ], + "metadata": { + "id": "e67KXr82SsLE" + }, + "execution_count": 47, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# print(city.crs) #{'init': 'epsg:3857'}\n", + "# city.plot()" + ], + "metadata": { + "id": "FbBjSeTnTUUT" + }, + "execution_count": 48, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# city = city.to_crs(epsg='32650')\n" + ], + "metadata": { + "id": "RjaSWyYxTjF1" + }, + "execution_count": 49, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# city = city.to_crs({'init':'epsg:32650'}, inplace = True)" + ], + "metadata": { + "id": "RuSsQ6IvS6zu" + }, + "execution_count": 50, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# city.to_crs(epsg = \"25833\", inplace = True)" + ], + "metadata": { + "id": "5AbCTL86UMBq" + }, + "execution_count": 51, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "\n", + " # city = city.to_crs({'init':'epsg:32650'})\n", + " # city['area(/km)'] = city.apply(lambda row:row.geometry.area/1e6,axis=1)\n", + " # city1 = filter_small_area(city)\n", + " # city1.to_file(os.path.join(drive_file,export_file_name+'_urban_Area_big20_To_shape.shp'),driver='ESRI Shapefile',encoding='utf-8')\n", + " # CITY = gpd.read_file(os.path.join(drive_file,export_file_name+'_urban_Area_big20_To_shape.shp'))\n", + " # task = ee.batch.Export.image.toCloudStorage(\n", + " # image=F182012.clip(CITY),\n", + " # description='Training Export',\n", + " # fileNamePrefix=file_name,\n", + " # bucket=OUTPUT_BUCKET,\n", + " # scale=30,\n", + " # region=CITY.geometry())\n", + " # CITY.plot(figsize=(12,6))" + ], + "metadata": { + "id": "yRg5mNMlSp8Z" + }, + "execution_count": 52, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qzIyIOWfVMEK" + }, + "source": [ + "## 4.Raster to Vector" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": { + "id": "1G73SO8WkiUZ" + }, + "outputs": [], + "source": [ + "# #raster to vector\n", + "# def raster_to_shape(rasterfile,shapefile):\n", + "# data = gdal.Open(rasterfile, gdal.GA_ReadOnly)\n", + "# inband = data.GetRasterBand(1)\n", + "# drv = ogr.GetDriverByName('ESRI Shapefile')\n", + "# Polygon = drv.CreateDataSource(shapefile)\n", + "# prj = osr.SpatialReference()\n", + "# prj.ImportFromWkt(data.GetProjection()) \n", + "# Polygon_layer = Polygon.CreateLayer(shapefile, srs=prj, geom_type = ogr.wkbMultiPolygon)\n", + "# newField = ogr.FieldDefn('Value', ogr.OFTInteger)\n", + "# Polygon_layer.CreateField(newField)\n", + "# gdal.FPolygonize(inband, None, Polygon_layer, 0)" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": { + "id": "_OLJl5x1Jwas" + }, + "outputs": [], + "source": [ + "# def filter_small_area(shape):\n", + "# for i in range(len(shape)):\n", + "# if shape.loc[i]['Value'] == 0:\n", + "# shape.drop([i],axis=0,inplace=True)\n", + "# shape = shape.sort_values(by='area(/km)',ascending=False)\n", + "# shape.drop(shape.index[10:],inplace=True)\n", + "# return shape" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": { + "id": "NpCJ0XSsOlF0" + }, + "outputs": [], + "source": [ + "# def uploadToGCP(city_cn,city_name,export_file_name):\n", + "# \"\"\"\n", + "# city_CN:'Guangzhou City'\n", + "# city_name:'Guangzhou'\n", + "# export_file_name:'Guangzhou_city'\n", + "# \"\"\"\n", + "# city_shape,city_ndui,city_mask = filter_city_ndui(city_cn)#'Shenzhen'\n", + "# task = export_task(city_mask,city_shape,export_file_name)#'shenzhen_city'\n", + "# task.start()\n", + "# print(ee.batch.Task.list())\n", + "# while task.active():\n", + "# print('Polling for task (id: {}).'.format(task.id))\n", + "# time.sleep(30)\n", + "# print('Done with image export.')\n", + "# if ee.batch.Task.list()[0].status()['state'] == 'FAILED':\n", + "# print('Upload File Failed,due to '+ee.batch.Task.list()[0].status()['error_message'])\n", + "# found_file(export_file_name)\n", + "# drive_file = os.path.join('/content/drive/MyDrive/',city_name)\n", + "# if not os.path.exists(drive_file):\n", + "# os.mkdir(drive_file)\n", + "# #gcp_path = 'gs://nduicity_luo/'+export_file_name+'.tif'\n", + "# gcp_path = 'drive/MyDrive/'+export_file_name+'.tif'\n", + "# print('gcp_path:',gcp_path)\n", + "# print('drive_file:',drive_file)" + ] + }, + { + "cell_type": "code", + "source": [ + "# city_shape,city_ndui,city_mask = filter_city_ndui('Guangzhou City')" + ], + "metadata": { + "id": "_9-Mmbe4VoLa" + }, + "execution_count": 56, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# task = export_task(city_mask,city_shape,'Guangzhou_city')" + ], + "metadata": { + "id": "y-OO_4YdWVyr" + }, + "execution_count": 57, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# task.start()" + ], + "metadata": { + "id": "7nR9yugSWfJX" + }, + "execution_count": 58, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# uploadToGCP('Guangzhou City','Guangzhou','Guanghzou_city')" + ], + "metadata": { + "id": "6W2ggRuCVTT7" + }, + "execution_count": 59, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Ctn81iKrVMEL" + }, + "source": [ + "## 5.Get the built-up areas shapefile" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": { + "id": "pBr40T6nql9w" + }, + "outputs": [], + "source": [ + "# def main(city_name,export_file_name):\n", + "# \"\"\"\n", + "# city_name:'Guangzhou'\n", + "# export_file_name:'guangzhou_city'\n", + "# \"\"\"\n", + "# raster_to_shape(os.path.join(drive_file,export_file_name+'.tif'),os.path.join(drive_file,export_file_name+'_urban_shape.shp'))\n", + "# city = gpd.read_file(os.path.join(drive_file,export_file_name+'_urban_shape.shp'))\n", + "# city = city.to_crs({'init':'epsg:32650'})\n", + "# city['area(/km)'] = city.apply(lambda row:row.geometry.area/1e6,axis=1)\n", + "# city1 = filter_small_area(city)\n", + "# city1.to_file(os.path.join(drive_file,export_file_name+'_urban_Area_big20_To_shape.shp'),driver='ESRI Shapefile',encoding='utf-8')\n", + "# CITY = gpd.read_file(os.path.join(drive_file,export_file_name+'_urban_Area_big20_To_shape.shp'))\n", + "# task = ee.batch.Export.image.toCloudStorage(\n", + "# image=F182012.clip(CITY),\n", + "# description='Training Export',\n", + "# fileNamePrefix=file_name,\n", + "# bucket=OUTPUT_BUCKET,\n", + "# scale=30,\n", + "# region=CITY.geometry())\n", + "# CITY.plot(figsize=(12,6))" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "id": "FZwBinaprrCH" + }, + "outputs": [], + "source": [ + "#uploadToGCP('Guangzhou City','Guangzhou','Guanghzou_city')" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "id": "eWsBrOUwrMVC" + }, + "outputs": [], + "source": [ + "#!gsutil cp gcp_path drive_file\n", + "#!gsutil cp gs://ndui_city/Guanghzou_city.tif /content/drive/MyDrive/GuangZhouCity" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "id": "U0k7KVEHryTX" + }, + "outputs": [], + "source": [ + "#main('Guanghzou','Guanghzou_city')" + ] + }, + { + "cell_type": "code", + "source": [ + "" + ], + "metadata": { + "id": "8J1mnRb4VHu0" + }, + "execution_count": null, + "outputs": [] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [], + "name": "NDUI.ipynb", + "provenance": [] + }, + "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.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file From 18c3b83579118e2f3bea4fe4afe388c95df40606 Mon Sep 17 00:00:00 2001 From: Manmeet Singh Date: Wed, 31 Aug 2022 01:40:13 -0500 Subject: [PATCH 07/14] Create README.md --- gee/README.md | 1 + 1 file changed, 1 insertion(+) create mode 100644 gee/README.md diff --git a/gee/README.md b/gee/README.md new file mode 100644 index 0000000..4ec4093 --- /dev/null +++ b/gee/README.md @@ -0,0 +1 @@ +Google Earth Engine notebooks From 2e0390a4df5b374432000d56a3ec1828795a9dcb Mon Sep 17 00:00:00 2001 From: Manmeet Singh Date: Wed, 31 Aug 2022 01:40:38 -0500 Subject: [PATCH 08/14] Add files via upload --- ...raster_geotiff_xarray_gdal_ee_folium.ipynb | 2886 +++++++++++++++++ 1 file changed, 2886 insertions(+) create mode 100644 gee/raster_geotiff_xarray_gdal_ee_folium.ipynb diff --git a/gee/raster_geotiff_xarray_gdal_ee_folium.ipynb b/gee/raster_geotiff_xarray_gdal_ee_folium.ipynb new file mode 100644 index 0000000..1f1b487 --- /dev/null +++ b/gee/raster_geotiff_xarray_gdal_ee_folium.ipynb @@ -0,0 +1,2886 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "raster_geotiff_xarray_gdal_ee_folium.ipynb", + "provenance": [], + "collapsed_sections": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "5xZjJiHCmT9D" + }, + "outputs": [], + "source": [ + "from google.colab import auth\n", + "auth.authenticate_user()" + ] + }, + { + "cell_type": "code", + "source": [ + "from google.colab import drive\n", + "drive.mount('/content/drive')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "xUZiZZ_3mm7B", + "outputId": "ef3dc1a8-eb13-461f-c206-542e87f678cc" + }, + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import ee, folium" + ], + "metadata": { + "id": "lgv_fo23mxP6" + }, + "execution_count": 3, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "import ee\n", + "ee.Authenticate()\n", + "ee.Initialize()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NeQ4vgM6m2VU", + "outputId": "03ce3a46-11c5-4a43-89e3-3277f9b7ef89" + }, + "execution_count": 4, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "To authorize access needed by Earth Engine, open the following URL in a web browser and follow the instructions. If the web browser does not start automatically, please manually browse the URL below.\n", + "\n", + " https://code.earthengine.google.com/client-auth?scopes=https%3A//www.googleapis.com/auth/earthengine%20https%3A//www.googleapis.com/auth/devstorage.full_control&request_id=7CHiWtberx62d2Td8Sq4GkB3nJ3r1Xn76V-fbtUaAcw&tc=vBfkbX_BZJWJNAcGWjBqW7R6K0QpnSM6NIQJ2AKuupY&cc=FtaX67e2EOTpr3pWqjzkVSrjZxhNQuiuu3gCYIKx2R0\n", + "\n", + "The authorization workflow will generate a code, which you should paste in the box below.\n", + "Enter verification code: 4/1AdQt8qgLYjG0RZixDtafM96KijvCYVpz8ac-CE8UAdPN3NAEDuKyQbRHRbI\n", + "\n", + "Successfully saved authorization token.\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "landsat = ee.Image('LANDSAT/LC08/C01/T1_TOA/LC08_123032_20140515').select(['B4', 'B3', 'B2'])" + ], + "metadata": { + "id": "1Wgr1ANem38n" + }, + "execution_count": 25, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "landsat" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "5GTOQ8mdtC_B", + "outputId": "5d9e2f7f-d941-4a74-d595-16c7709ab5b1" + }, + "execution_count": 26, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 26 + } + ] + }, + { + "cell_type": "code", + "source": [ + "u_lon = 116.2621\n", + "u_lat = 39.8412\n", + "u_poi = ee.Geometry.Point(u_lon, u_lat)\n", + "# Create a buffer zone of 10 km around Lyon.\n", + "lyon = u_poi.buffer(10000) # meters" + ], + "metadata": { + "id": "_Rs7fY4DrDE-" + }, + "execution_count": 27, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "task = ee.batch.Export.image.toDrive(image=landsat,\n", + " description='landsat_image',\n", + " scale=30,\n", + " region=lyon,\n", + " fileNamePrefix='landsat',\n", + " crs='EPSG:4326',\n", + " fileFormat='GeoTIFF'\n", + " )\n", + "task.start()" + ], + "metadata": { + "id": "7stCKD7JqQ1b" + }, + "execution_count": 8, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "!ls drive/MyDrive/landsat*" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "3cOaRxl7rx0K", + "outputId": "092c4a65-7067-4480-8908-2ccfa56431f3" + }, + "execution_count": 28, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "drive/MyDrive/landsat.tif\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "!sudo add-apt-repository ppa:ubuntugis/ppa" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "p2zuz6q4sRqq", + "outputId": "c79e8dd7-de5d-4258-ded6-bb792be310e2" + }, + "execution_count": 10, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " Official stable UbuntuGIS packages.\n", + "\n", + "\n", + " More info: https://launchpad.net/~ubuntugis/+archive/ubuntu/ppa\n", + "Press [ENTER] to continue or Ctrl-c to cancel adding it.\n", + "\n", + "Hit:1 http://security.ubuntu.com/ubuntu bionic-security InRelease\n", + "Hit:2 https://cloud.r-project.org/bin/linux/ubuntu bionic-cran40/ InRelease\n", + "Ign:3 https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64 InRelease\n", + "Hit:4 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64 InRelease\n", + "Hit:5 https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64 Release\n", + "Hit:6 http://ppa.launchpad.net/c2d4u.team/c2d4u4.0+/ubuntu bionic InRelease\n", + "Hit:7 http://archive.ubuntu.com/ubuntu bionic InRelease\n", + "0% [1 InRelease gpgv 88.7 kB] [Waiting for headers] [Connecting to ppa.launchpa\n", + "Hit:8 http://archive.ubuntu.com/ubuntu bionic-updates InRelease\n", + "Hit:9 http://archive.ubuntu.com/ubuntu bionic-backports InRelease\n", + "Hit:10 http://ppa.launchpad.net/cran/libgit2/ubuntu bionic InRelease\n", + "Hit:12 http://ppa.launchpad.net/deadsnakes/ppa/ubuntu bionic InRelease\n", + "Hit:13 http://ppa.launchpad.net/graphics-drivers/ppa/ubuntu bionic InRelease\n", + "Hit:14 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic InRelease\n", + "Reading package lists... Done\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "!sudo apt-get update" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Bw4x3N5qsgMM", + "outputId": "9e8d3001-cf85-4db3-b550-230e35752240" + }, + "execution_count": 11, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\r0% [Working]\r \rHit:1 https://cloud.r-project.org/bin/linux/ubuntu bionic-cran40/ InRelease\n", + "\r0% [Connecting to archive.ubuntu.com] [Waiting for headers] [Waiting for header\r0% [1 InRelease gpgv 3,626 B] [Connecting to archive.ubuntu.com] [Waiting for h\r \rHit:2 http://security.ubuntu.com/ubuntu bionic-security InRelease\n", + "\r0% [1 InRelease gpgv 3,626 B] [Connecting to archive.ubuntu.com] [Waiting for h\r \rIgn:3 https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64 InRelease\n", + "Hit:4 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64 InRelease\n", + "Hit:5 https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64 Release\n", + "Hit:6 http://ppa.launchpad.net/c2d4u.team/c2d4u4.0+/ubuntu bionic InRelease\n", + "Hit:7 http://archive.ubuntu.com/ubuntu bionic InRelease\n", + "Hit:8 http://ppa.launchpad.net/cran/libgit2/ubuntu bionic InRelease\n", + "Hit:9 http://archive.ubuntu.com/ubuntu bionic-updates InRelease\n", + "Hit:11 http://archive.ubuntu.com/ubuntu bionic-backports InRelease\n", + "Hit:12 http://ppa.launchpad.net/deadsnakes/ppa/ubuntu bionic InRelease\n", + "Hit:13 http://ppa.launchpad.net/graphics-drivers/ppa/ubuntu bionic InRelease\n", + "Hit:14 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic InRelease\n", + "Reading package lists... Done\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "!sudo apt-get install gdal-bin libgdal-dev" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Xi01TLQPsiKh", + "outputId": "510a9d08-ccdc-4769-e69a-706798cdbe1b" + }, + "execution_count": 12, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Reading package lists... Done\n", + "Building dependency tree \n", + "Reading state information... Done\n", + "gdal-bin is already the newest version (2.4.2+dfsg-1~bionic0).\n", + "libgdal-dev is already the newest version (2.4.2+dfsg-1~bionic0).\n", + "The following package was automatically installed and is no longer required:\n", + " libnvidia-common-460\n", + "Use 'sudo apt autoremove' to remove it.\n", + "0 upgraded, 0 newly installed, 0 to remove and 55 not upgraded.\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "!pip install -U pip" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "y3oPa31Es4A_", + "outputId": "56984f21-9830-4fb2-f960-bfc3d619e8ed" + }, + "execution_count": 13, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Collecting pip\n", + " Using cached pip-22.2.2-py3-none-any.whl (2.0 MB)\n", + "Installing collected packages: pip\n", + " Attempting uninstall: pip\n", + " Found existing installation: pip 20.0.2\n", + " Uninstalling pip-20.0.2:\n", + " Successfully uninstalled pip-20.0.2\n", + "Successfully installed pip-22.2.2\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "!pip install rasterio" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "dl54ttqTtjsN", + "outputId": "9d8883ca-81ef-47ab-ff87-5c6f47c368ae" + }, + "execution_count": 14, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Collecting rasterio\n", + " Using cached rasterio-1.2.10-cp37-cp37m-manylinux1_x86_64.whl (19.3 MB)\n", + "Collecting snuggs>=1.4.1\n", + " Using cached snuggs-1.4.7-py3-none-any.whl (5.4 kB)\n", + "Collecting cligj>=0.5\n", + " Using cached cligj-0.7.2-py3-none-any.whl (7.1 kB)\n", + "Requirement already satisfied: certifi in /usr/local/lib/python3.7/site-packages (from rasterio) (2019.11.28)\n", + "Requirement already satisfied: setuptools in /usr/local/lib/python3.7/site-packages (from rasterio) (45.2.0.post20200210)\n", + "Collecting click-plugins\n", + " Using cached click_plugins-1.1.1-py2.py3-none-any.whl (7.5 kB)\n", + "Requirement already satisfied: click>=4.0 in /usr/local/lib/python3.7/site-packages (from rasterio) (7.0)\n", + "Collecting affine\n", + " Using cached affine-2.3.1-py2.py3-none-any.whl (16 kB)\n", + "Requirement already satisfied: attrs in /usr/local/lib/python3.7/site-packages (from rasterio) (19.3.0)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.7/site-packages (from rasterio) (1.18.1)\n", + "Requirement already satisfied: pyparsing>=2.1.6 in /usr/local/lib/python3.7/site-packages (from snuggs>=1.4.1->rasterio) (2.4.6)\n", + "Installing collected packages: affine, snuggs, cligj, click-plugins, rasterio\n", + "Successfully installed affine-2.3.1 click-plugins-1.1.1 cligj-0.7.2 rasterio-1.2.10 snuggs-1.4.7\n", + "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[0m" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import rasterio\n", + "from rasterio.plot import show\n", + "fp = r'drive/MyDrive/landsat.tif'\n", + "img = rasterio.open(fp)\n", + "show(img)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 283 + }, + "id": "lX7uGII3BLfs", + "outputId": "83f94042-dceb-4c8e-ab15-9c10dbb34fe5" + }, + "execution_count": 15, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 15 + } + ] + }, + { + "cell_type": "code", + "source": [ + "print(img.count)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "jj9UKKKysJiM", + "outputId": "a0807d24-80bd-4941-9e7d-af4d92d07aaf" + }, + "execution_count": 16, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "3\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "print(img.height, img.width)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "rmcFE6vEu15Y", + "outputId": "83e23096-4d99-46ff-b7c5-8dc2cf7814d3" + }, + "execution_count": 17, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "669 865\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "print(img.crs)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "QBsGA0hQu-he", + "outputId": "6c10b606-a4c6-4e6a-fc7c-2a4fc0154d79" + }, + "execution_count": 18, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "EPSG:4326\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import xarray as xr" + ], + "metadata": { + "id": "SvMPVoXzvBap" + }, + "execution_count": 19, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "da = xr.open_rasterio(\"drive/MyDrive/landsat.tif\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "d3IjxHXsvO09", + "outputId": "5307e14f-2121-4fd6-f35f-65967cf4962f" + }, + "execution_count": 20, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:1: DeprecationWarning: open_rasterio is Deprecated in favor of rioxarray. For information about transitioning, see: https://corteva.github.io/rioxarray/stable/getting_started/getting_started.html\n", + " \"\"\"Entry point for launching an IPython kernel.\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "da" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 367 + }, + "id": "ix2iBPAavW4n", + "outputId": "0ef63b89-0504-4bbe-e378-fc1ab0c84384" + }, + "execution_count": 21, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "\n", + "[1736055 values with dtype=float32]\n", + "Coordinates:\n", + " * band (band) int64 1 2 3\n", + " * y (y) float64 39.93 39.93 39.93 39.93 ... 39.75 39.75 39.75 39.75\n", + " * x (x) float64 116.1 116.1 116.1 116.1 ... 116.4 116.4 116.4 116.4\n", + "Attributes:\n", + " transform: (0.00026949458523585647, 0.0, 116.14569836660849, 0.0, -0...\n", + " crs: +init=epsg:4326\n", + " res: (0.00026949458523585647, 0.00026949458523585647)\n", + " is_tiled: 1\n", + " nodatavals: (nan, nan, nan)\n", + " scales: (1.0, 1.0, 1.0)\n", + " offsets: (0.0, 0.0, 0.0)\n", + " descriptions: ('B4', 'B3', 'B2')\n", + " AREA_OR_POINT: Area" + ], + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray (band: 3, y: 669, x: 865)>\n",
+              "[1736055 values with dtype=float32]\n",
+              "Coordinates:\n",
+              "  * band     (band) int64 1 2 3\n",
+              "  * y        (y) float64 39.93 39.93 39.93 39.93 ... 39.75 39.75 39.75 39.75\n",
+              "  * x        (x) float64 116.1 116.1 116.1 116.1 ... 116.4 116.4 116.4 116.4\n",
+              "Attributes:\n",
+              "    transform:      (0.00026949458523585647, 0.0, 116.14569836660849, 0.0, -0...\n",
+              "    crs:            +init=epsg:4326\n",
+              "    res:            (0.00026949458523585647, 0.00026949458523585647)\n",
+              "    is_tiled:       1\n",
+              "    nodatavals:     (nan, nan, nan)\n",
+              "    scales:         (1.0, 1.0, 1.0)\n",
+              "    offsets:        (0.0, 0.0, 0.0)\n",
+              "    descriptions:   ('B4', 'B3', 'B2')\n",
+              "    AREA_OR_POINT:  Area
" + ] + }, + "metadata": {}, + "execution_count": 21 + } + ] + }, + { + "cell_type": "code", + "source": [ + "da.shape" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "pONA1FUbOLuR", + "outputId": "94e48383-e22c-47b3-f01e-a400e3c03c09" + }, + "execution_count": 31, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(3, 669, 865)" + ] + }, + "metadata": {}, + "execution_count": 31 + } + ] + }, + { + "cell_type": "code", + "source": [ + "! wget https://repo.anaconda.com/archive/Anaconda3-2020.02-Linux-x86_64.sh\n", + "! chmod +x Anaconda3-2020.02-Linux-x86_64.sh\n", + "! bash ./Anaconda3-2020.02-Linux-x86_64.sh -b -f -p /usr/local\n", + "import sys\n", + "sys.path.append('/usr/local/lib/python3.7/site-packages/')\n", + "! conda update -n base -c defaults conda -y\n", + "! conda config --add channels bioconda\n", + "! conda config --add channels conda-forge" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "jPbxGv4EwAr-", + "outputId": "61281cee-eec1-4bc7-b353-09f0d5ca44b0" + }, + "execution_count": 22, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "--2022-08-31 04:41:22-- https://repo.anaconda.com/archive/Anaconda3-2020.02-Linux-x86_64.sh\n", + "Resolving repo.anaconda.com (repo.anaconda.com)... 104.16.130.3, 104.16.131.3, 2606:4700::6810:8303, ...\n", + "Connecting to repo.anaconda.com (repo.anaconda.com)|104.16.130.3|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 546910666 (522M) [application/x-sh]\n", + "Saving to: ‘Anaconda3-2020.02-Linux-x86_64.sh.1’\n", + "\n", + "Anaconda3-2020.02-L 100%[===================>] 521.57M 88.1MB/s in 5.3s \n", + "\n", + "2022-08-31 04:41:28 (98.9 MB/s) - ‘Anaconda3-2020.02-Linux-x86_64.sh.1’ saved [546910666/546910666]\n", + "\n", + "PREFIX=/usr/local\n", + "Unpacking payload ...\n", + "Collecting package metadata (current_repodata.json): - \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\bdone\n", + "Solving environment: / \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\bdone\n", + "\n", + "## Package Plan ##\n", + "\n", + " environment location: /usr/local\n", + "\n", + " added / updated specs:\n", + " - _ipyw_jlab_nb_ext_conf==0.1.0=py37_0\n", + " - _libgcc_mutex==0.1=main\n", + " - alabaster==0.7.12=py37_0\n", + " - anaconda-client==1.7.2=py37_0\n", + " - anaconda-navigator==1.9.12=py37_0\n", + " - anaconda-project==0.8.4=py_0\n", + " - anaconda==2020.02=py37_0\n", + " - argh==0.26.2=py37_0\n", + " - asn1crypto==1.3.0=py37_0\n", + " - astroid==2.3.3=py37_0\n", + " - astropy==4.0=py37h7b6447c_0\n", + " - atomicwrites==1.3.0=py37_1\n", + " - attrs==19.3.0=py_0\n", + " - autopep8==1.4.4=py_0\n", + " - babel==2.8.0=py_0\n", + " - backcall==0.1.0=py37_0\n", + " - backports.functools_lru_cache==1.6.1=py_0\n", + " - backports.shutil_get_terminal_size==1.0.0=py37_2\n", + " - backports.tempfile==1.0=py_1\n", + " - backports.weakref==1.0.post1=py_1\n", + " - backports==1.0=py_2\n", + " - beautifulsoup4==4.8.2=py37_0\n", + " - bitarray==1.2.1=py37h7b6447c_0\n", + " - bkcharts==0.2=py37_0\n", + " - blas==1.0=mkl\n", + " - bleach==3.1.0=py37_0\n", + " - blosc==1.16.3=hd408876_0\n", + " - bokeh==1.4.0=py37_0\n", + " - boto==2.49.0=py37_0\n", + " - bottleneck==1.3.2=py37heb32a55_0\n", + " - bzip2==1.0.8=h7b6447c_0\n", + " - ca-certificates==2020.1.1=0\n", + " - cairo==1.14.12=h8948797_3\n", + " - certifi==2019.11.28=py37_0\n", + " - cffi==1.14.0=py37h2e261b9_0\n", + " - chardet==3.0.4=py37_1003\n", + " - click==7.0=py37_0\n", + " - cloudpickle==1.3.0=py_0\n", + " - clyent==1.2.2=py37_1\n", + " - colorama==0.4.3=py_0\n", + " - conda-build==3.18.11=py37_0\n", + " - conda-env==2.6.0=1\n", + " - conda-package-handling==1.6.0=py37h7b6447c_0\n", + " - conda-verify==3.4.2=py_1\n", + " - conda==4.8.2=py37_0\n", + " - contextlib2==0.6.0.post1=py_0\n", + " - cryptography==2.8=py37h1ba5d50_0\n", + " - curl==7.68.0=hbc83047_0\n", + " - cycler==0.10.0=py37_0\n", + " - cython==0.29.15=py37he6710b0_0\n", + " - cytoolz==0.10.1=py37h7b6447c_0\n", + " - dask-core==2.11.0=py_0\n", + " - dask==2.11.0=py_0\n", + " - dbus==1.13.12=h746ee38_0\n", + " - decorator==4.4.1=py_0\n", + " - defusedxml==0.6.0=py_0\n", + " - diff-match-patch==20181111=py_0\n", + " - distributed==2.11.0=py37_0\n", + " - docutils==0.16=py37_0\n", + " - entrypoints==0.3=py37_0\n", + " - et_xmlfile==1.0.1=py37_0\n", + " - expat==2.2.6=he6710b0_0\n", + " - fastcache==1.1.0=py37h7b6447c_0\n", + " - filelock==3.0.12=py_0\n", + " - flake8==3.7.9=py37_0\n", + " - flask==1.1.1=py_0\n", + " - fontconfig==2.13.0=h9420a91_0\n", + " - freetype==2.9.1=h8a8886c_1\n", + " - fribidi==1.0.5=h7b6447c_0\n", + " - fsspec==0.6.2=py_0\n", + " - future==0.18.2=py37_0\n", + " - get_terminal_size==1.0.0=haa9412d_0\n", + " - gevent==1.4.0=py37h7b6447c_0\n", + " - glib==2.63.1=h5a9c865_0\n", + " - glob2==0.7=py_0\n", + " - gmp==6.1.2=h6c8ec71_1\n", + " - gmpy2==2.0.8=py37h10f8cd9_2\n", + " - graphite2==1.3.13=h23475e2_0\n", + " - greenlet==0.4.15=py37h7b6447c_0\n", + " - gst-plugins-base==1.14.0=hbbd80ab_1\n", + " - gstreamer==1.14.0=hb453b48_1\n", + " - h5py==2.10.0=py37h7918eee_0\n", + " - harfbuzz==1.8.8=hffaf4a1_0\n", + " - hdf5==1.10.4=hb1b8bf9_0\n", + " - heapdict==1.0.1=py_0\n", + " - html5lib==1.0.1=py37_0\n", + " - hypothesis==5.5.4=py_0\n", + " - icu==58.2=h9c2bf20_1\n", + " - idna==2.8=py37_0\n", + " - imageio==2.6.1=py37_0\n", + " - imagesize==1.2.0=py_0\n", + " - importlib_metadata==1.5.0=py37_0\n", + " - intel-openmp==2020.0=166\n", + " - intervaltree==3.0.2=py_0\n", + " - ipykernel==5.1.4=py37h39e3cac_0\n", + " - ipython==7.12.0=py37h5ca1d4c_0\n", + " - ipython_genutils==0.2.0=py37_0\n", + " - ipywidgets==7.5.1=py_0\n", + " - isort==4.3.21=py37_0\n", + " - itsdangerous==1.1.0=py37_0\n", + " - jbig==2.1=hdba287a_0\n", + " - jdcal==1.4.1=py_0\n", + " - jedi==0.14.1=py37_0\n", + " - jeepney==0.4.2=py_0\n", + " - jinja2==2.11.1=py_0\n", + " - joblib==0.14.1=py_0\n", + " - jpeg==9b=h024ee3a_2\n", + " - json5==0.9.1=py_0\n", + " - jsonschema==3.2.0=py37_0\n", + " - jupyter==1.0.0=py37_7\n", + " - jupyter_client==5.3.4=py37_0\n", + " - jupyter_console==6.1.0=py_0\n", + " - jupyter_core==4.6.1=py37_0\n", + " - jupyterlab==1.2.6=pyhf63ae98_0\n", + " - jupyterlab_server==1.0.6=py_0\n", + " - keyring==21.1.0=py37_0\n", + " - kiwisolver==1.1.0=py37he6710b0_0\n", + " - krb5==1.17.1=h173b8e3_0\n", + " - lazy-object-proxy==1.4.3=py37h7b6447c_0\n", + " - ld_impl_linux-64==2.33.1=h53a641e_7\n", + " - libarchive==3.3.3=h5d8350f_5\n", + " - libcurl==7.68.0=h20c2e04_0\n", + " - libedit==3.1.20181209=hc058e9b_0\n", + " - libffi==3.2.1=hd88cf55_4\n", + " - libgcc-ng==9.1.0=hdf63c60_0\n", + " - libgfortran-ng==7.3.0=hdf63c60_0\n", + " - liblief==0.9.0=h7725739_2\n", + " - libpng==1.6.37=hbc83047_0\n", + " - libsodium==1.0.16=h1bed415_0\n", + " - libspatialindex==1.9.3=he6710b0_0\n", + " - libssh2==1.8.2=h1ba5d50_0\n", + " - libstdcxx-ng==9.1.0=hdf63c60_0\n", + " - libtiff==4.1.0=h2733197_0\n", + " - libtool==2.4.6=h7b6447c_5\n", + " - libuuid==1.0.3=h1bed415_2\n", + " - libxcb==1.13=h1bed415_1\n", + " - libxml2==2.9.9=hea5a465_1\n", + " - libxslt==1.1.33=h7d1a2b0_0\n", + " - llvmlite==0.31.0=py37hd408876_0\n", + " - locket==0.2.0=py37_1\n", + " - lxml==4.5.0=py37hefd8a0e_0\n", + " - lz4-c==1.8.1.2=h14c3975_0\n", + " - lzo==2.10=h49e0be7_2\n", + " - markupsafe==1.1.1=py37h7b6447c_0\n", + " - matplotlib-base==3.1.3=py37hef1b27d_0\n", + " - matplotlib==3.1.3=py37_0\n", + " - mccabe==0.6.1=py37_1\n", + " - mistune==0.8.4=py37h7b6447c_0\n", + " - mkl-service==2.3.0=py37he904b0f_0\n", + " - mkl==2020.0=166\n", + " - mkl_fft==1.0.15=py37ha843d7b_0\n", + " - mkl_random==1.1.0=py37hd6b4f25_0\n", + " - mock==4.0.1=py_0\n", + " - more-itertools==8.2.0=py_0\n", + " - mpc==1.1.0=h10f8cd9_1\n", + " - mpfr==4.0.1=hdf1c602_3\n", + " - mpmath==1.1.0=py37_0\n", + " - msgpack-python==0.6.1=py37hfd86e86_1\n", + " - multipledispatch==0.6.0=py37_0\n", + " - navigator-updater==0.2.1=py37_0\n", + " - nbconvert==5.6.1=py37_0\n", + " - nbformat==5.0.4=py_0\n", + " - ncurses==6.2=he6710b0_0\n", + " - networkx==2.4=py_0\n", + " - nltk==3.4.5=py37_0\n", + " - nose==1.3.7=py37_2\n", + " - notebook==6.0.3=py37_0\n", + " - numba==0.48.0=py37h0573a6f_0\n", + " - numexpr==2.7.1=py37h423224d_0\n", + " - numpy-base==1.18.1=py37hde5b4d6_1\n", + " - numpy==1.18.1=py37h4f9e942_0\n", + " - numpydoc==0.9.2=py_0\n", + " - olefile==0.46=py37_0\n", + " - openpyxl==3.0.3=py_0\n", + " - openssl==1.1.1d=h7b6447c_4\n", + " - packaging==20.1=py_0\n", + " - pandas==1.0.1=py37h0573a6f_0\n", + " - pandoc==2.2.3.2=0\n", + " - pandocfilters==1.4.2=py37_1\n", + " - pango==1.42.4=h049681c_0\n", + " - parso==0.5.2=py_0\n", + " - partd==1.1.0=py_0\n", + " - patchelf==0.10=he6710b0_0\n", + " - path.py==12.4.0=0\n", + " - path==13.1.0=py37_0\n", + " - pathlib2==2.3.5=py37_0\n", + " - pathtools==0.1.2=py_1\n", + " - patsy==0.5.1=py37_0\n", + " - pcre==8.43=he6710b0_0\n", + " - pep8==1.7.1=py37_0\n", + " - pexpect==4.8.0=py37_0\n", + " - pickleshare==0.7.5=py37_0\n", + " - pillow==7.0.0=py37hb39fc2d_0\n", + " - pip==20.0.2=py37_1\n", + " - pixman==0.38.0=h7b6447c_0\n", + " - pkginfo==1.5.0.1=py37_0\n", + " - pluggy==0.13.1=py37_0\n", + " - ply==3.11=py37_0\n", + " - prometheus_client==0.7.1=py_0\n", + " - prompt_toolkit==3.0.3=py_0\n", + " - psutil==5.6.7=py37h7b6447c_0\n", + " - ptyprocess==0.6.0=py37_0\n", + " - py-lief==0.9.0=py37h7725739_2\n", + " - py==1.8.1=py_0\n", + " - pycodestyle==2.5.0=py37_0\n", + " - pycosat==0.6.3=py37h7b6447c_0\n", + " - pycparser==2.19=py37_0\n", + " - pycrypto==2.6.1=py37h14c3975_9\n", + " - pycurl==7.43.0.5=py37h1ba5d50_0\n", + " - pydocstyle==4.0.1=py_0\n", + " - pyflakes==2.1.1=py37_0\n", + " - pygments==2.5.2=py_0\n", + " - pylint==2.4.4=py37_0\n", + " - pyodbc==4.0.30=py37he6710b0_0\n", + " - pyopenssl==19.1.0=py37_0\n", + " - pyparsing==2.4.6=py_0\n", + " - pyqt==5.9.2=py37h05f1152_2\n", + " - pyrsistent==0.15.7=py37h7b6447c_0\n", + " - pysocks==1.7.1=py37_0\n", + " - pytables==3.6.1=py37h71ec239_0\n", + " - pytest-arraydiff==0.3=py37h39e3cac_0\n", + " - pytest-astropy-header==0.1.2=py_0\n", + " - pytest-astropy==0.8.0=py_0\n", + " - pytest-doctestplus==0.5.0=py_0\n", + " - pytest-openfiles==0.4.0=py_0\n", + " - pytest-remotedata==0.3.2=py37_0\n", + " - pytest==5.3.5=py37_0\n", + " - python-dateutil==2.8.1=py_0\n", + " - python-jsonrpc-server==0.3.4=py_0\n", + " - python-language-server==0.31.7=py37_0\n", + " - python-libarchive-c==2.8=py37_13\n", + " - python==3.7.6=h0371630_2\n", + " - pytz==2019.3=py_0\n", + " - pywavelets==1.1.1=py37h7b6447c_0\n", + " - pyxdg==0.26=py_0\n", + " - pyyaml==5.3=py37h7b6447c_0\n", + " - pyzmq==18.1.1=py37he6710b0_0\n", + " - qdarkstyle==2.8=py_0\n", + " - qt==5.9.7=h5867ecd_1\n", + " - qtawesome==0.6.1=py_0\n", + " - qtconsole==4.6.0=py_1\n", + " - qtpy==1.9.0=py_0\n", + " - readline==7.0=h7b6447c_5\n", + " - requests==2.22.0=py37_1\n", + " - ripgrep==11.0.2=he32d670_0\n", + " - rope==0.16.0=py_0\n", + " - rtree==0.9.3=py37_0\n", + " - ruamel_yaml==0.15.87=py37h7b6447c_0\n", + " - scikit-image==0.16.2=py37h0573a6f_0\n", + " - scikit-learn==0.22.1=py37hd81dba3_0\n", + " - scipy==1.4.1=py37h0b6359f_0\n", + " - seaborn==0.10.0=py_0\n", + " - secretstorage==3.1.2=py37_0\n", + " - send2trash==1.5.0=py37_0\n", + " - setuptools==45.2.0=py37_0\n", + " - simplegeneric==0.8.1=py37_2\n", + " - singledispatch==3.4.0.3=py37_0\n", + " - sip==4.19.8=py37hf484d3e_0\n", + " - six==1.14.0=py37_0\n", + " - snappy==1.1.7=hbae5bb6_3\n", + " - snowballstemmer==2.0.0=py_0\n", + " - sortedcollections==1.1.2=py37_0\n", + " - sortedcontainers==2.1.0=py37_0\n", + " - soupsieve==1.9.5=py37_0\n", + " - sphinx==2.4.0=py_0\n", + " - sphinxcontrib-applehelp==1.0.1=py_0\n", + " - sphinxcontrib-devhelp==1.0.1=py_0\n", + " - sphinxcontrib-htmlhelp==1.0.2=py_0\n", + " - sphinxcontrib-jsmath==1.0.1=py_0\n", + " - sphinxcontrib-qthelp==1.0.2=py_0\n", + " - sphinxcontrib-serializinghtml==1.1.3=py_0\n", + " - sphinxcontrib-websupport==1.2.0=py_0\n", + " - sphinxcontrib==1.0=py37_1\n", + " - spyder-kernels==1.8.1=py37_0\n", + " - spyder==4.0.1=py37_0\n", + " - sqlalchemy==1.3.13=py37h7b6447c_0\n", + " - sqlite==3.31.1=h7b6447c_0\n", + " - statsmodels==0.11.0=py37h7b6447c_0\n", + " - sympy==1.5.1=py37_0\n", + " - tbb==2020.0=hfd86e86_0\n", + " - tblib==1.6.0=py_0\n", + " - terminado==0.8.3=py37_0\n", + " - testpath==0.4.4=py_0\n", + " - tk==8.6.8=hbc83047_0\n", + " - toolz==0.10.0=py_0\n", + " - tornado==6.0.3=py37h7b6447c_3\n", + " - tqdm==4.42.1=py_0\n", + " - traitlets==4.3.3=py37_0\n", + " - ujson==1.35=py37h14c3975_0\n", + " - unicodecsv==0.14.1=py37_0\n", + " - unixodbc==2.3.7=h14c3975_0\n", + " - urllib3==1.25.8=py37_0\n", + " - watchdog==0.10.2=py37_0\n", + " - wcwidth==0.1.8=py_0\n", + " - webencodings==0.5.1=py37_1\n", + " - werkzeug==1.0.0=py_0\n", + " - wheel==0.34.2=py37_0\n", + " - widgetsnbextension==3.5.1=py37_0\n", + " - wrapt==1.11.2=py37h7b6447c_0\n", + " - wurlitzer==2.0.0=py37_0\n", + " - xlrd==1.2.0=py37_0\n", + " - xlsxwriter==1.2.7=py_0\n", + " - xlwt==1.3.0=py37_0\n", + " - xmltodict==0.12.0=py_0\n", + " - xz==5.2.4=h14c3975_4\n", + " - yaml==0.1.7=had09818_2\n", + " - yapf==0.28.0=py_0\n", + " - zeromq==4.3.1=he6710b0_3\n", + " - zict==1.0.0=py_0\n", + " - zipp==2.2.0=py_0\n", + " - zlib==1.2.11=h7b6447c_3\n", + " - zstd==1.3.7=h0b5b093_0\n", + "\n", + "\n", + "The following packages will be SUPERSEDED by a higher-priority channel:\n", + "\n", + " conda conda-forge::conda-4.14.0-py37h89c186~ --> pkgs/main::conda-4.8.2-py37_0\n", + "\n", + "The following packages will be DOWNGRADED:\n", + "\n", + " backports.functoo~ 1.6.4-pyhd3eb1b0_0 --> 1.6.1-py_0\n", + " backports.tempfile 1.0-pyhd3eb1b0_1 --> 1.0-py_1\n", + " conda-package-han~ 1.8.1-py37h7f8727e_0 --> 1.6.0-py37h7b6447c_0\n", + " xmltodict 0.12.0-pyhd3eb1b0_0 --> 0.12.0-py_0\n", + "\n", + "\n", + "Preparing transaction: - \b\bdone\n", + "Executing transaction: | \b\b/ \b\b- \b\b\\ \b\b| \b\bdone\n", + "installation finished.\n", + "WARNING:\n", + " You currently have a PYTHONPATH environment variable set. This may cause\n", + " unexpected behavior when running the Python interpreter in Anaconda3.\n", + " For best results, please verify that your PYTHONPATH only points to\n", + " directories of packages that are compatible with the Python interpreter\n", + " in Anaconda3: /usr/local\n", + "Collecting package metadata (current_repodata.json): - \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\bdone\n", + "Solving environment: - \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\bdone\n", + "\n", + "## Package Plan ##\n", + "\n", + " environment location: /usr/local\n", + "\n", + " added / updated specs:\n", + " - conda\n", + "\n", + "\n", + "The following packages will be REMOVED:\n", + "\n", + " cartopy-0.18.0-py37h0d9ca2b_1\n", + " geos-3.8.0-he6710b0_0\n", + " proj-6.2.1-hc80f0dc_0\n", + " pyshp-2.3.1-pyhd8ed1ab_0\n", + " python_abi-3.7-2_cp37m\n", + " shapely-1.7.1-py37h1728cc4_0\n", + "\n", + "The following packages will be UPDATED:\n", + "\n", + " backports.functoo~ 1.6.1-py_0 --> 1.6.4-pyhd3eb1b0_0\n", + " conda 4.8.2-py37_0 --> 4.14.0-py37h06a4308_0\n", + " conda-package-han~ 1.6.0-py37h7b6447c_0 --> 1.8.1-py37h7f8727e_0\n", + "\n", + "The following packages will be DOWNGRADED:\n", + "\n", + " backports.tempfile 1.0-py_1 --> 1.0-pyhd3eb1b0_1\n", + " xmltodict 0.12.0-py_0 --> 0.12.0-pyhd3eb1b0_0\n", + "\n", + "\n", + "Preparing transaction: | \b\bdone\n", + "Verifying transaction: - \b\bdone\n", + "Executing transaction: | \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\bdone\n", + "Warning: 'bioconda' already in 'channels' list, moving to the top\n", + "Warning: 'conda-forge' already in 'channels' list, moving to the top\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "!conda install -c conda-forge cartopy" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "8lvLhvAHv24U", + "outputId": "80715c7c-d448-46f8-a134-bc57585d492a" + }, + "execution_count": 23, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting package metadata (current_repodata.json): - \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\bdone\n", + "Solving environment: \\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\bdone\n", + "\n", + "## Package Plan ##\n", + "\n", + " environment location: /usr/local\n", + "\n", + " added / updated specs:\n", + " - cartopy\n", + "\n", + "\n", + "The following NEW packages will be INSTALLED:\n", + "\n", + " cartopy pkgs/main/linux-64::cartopy-0.18.0-py37h0d9ca2b_1\n", + " geos pkgs/main/linux-64::geos-3.8.0-he6710b0_0\n", + " proj conda-forge/linux-64::proj-6.2.1-hc80f0dc_0\n", + " pyshp conda-forge/noarch::pyshp-2.3.1-pyhd8ed1ab_0\n", + " python_abi conda-forge/linux-64::python_abi-3.7-2_cp37m\n", + " shapely pkgs/main/linux-64::shapely-1.7.1-py37h1728cc4_0\n", + "\n", + "The following packages will be SUPERSEDED by a higher-priority channel:\n", + "\n", + " conda pkgs/main::conda-4.14.0-py37h06a4308_0 --> conda-forge::conda-4.14.0-py37h89c1867_0\n", + "\n", + "\n", + "Proceed ([y]/n)? \n", + "\n", + "Preparing transaction: \\ \b\bdone\n", + "Verifying transaction: / \b\b- \b\b\\ \b\b| \b\bdone\n", + "Executing transaction: - \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\b| \b\b/ \b\b- \b\b\\ \b\bdone\n", + "Retrieving notices: ...working... done\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import cartopy.crs as ccrs\n", + "import matplotlib.pyplot as plt\n", + "from rasterio.warp import transform\n", + "import numpy as np\n", + "\n", + "# Compute the lon/lat coordinates with rasterio.warp.transform\n", + "ny, nx = len(da['y']), len(da['x'])\n", + "x, y = np.meshgrid(da['x'], da['y'])\n", + "\n", + "# Rasterio works with 1D arrays\n", + "lon, lat = transform(da.crs, {'init': 'EPSG:4326'},\n", + " x.flatten(), y.flatten())\n", + "lon = np.asarray(lon).reshape((ny, nx))\n", + "lat = np.asarray(lat).reshape((ny, nx))\n", + "da.coords['lon'] = (('y', 'x'), lon)\n", + "da.coords['lat'] = (('y', 'x'), lat)\n", + "\n", + "# Compute a greyscale out of the rgb image\n", + "greyscale = da.mean(dim='band')\n", + "\n", + "# Plot on a map\n", + "ax = plt.subplot(projection=ccrs.PlateCarree())\n", + "greyscale.plot(ax=ax, x='lon', y='lat', transform=ccrs.PlateCarree(),\n", + " cmap='Greys_r', add_colorbar=False)\n", + "ax.coastlines('10m', color='r')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 283 + }, + "id": "MlxzGT0IvXqk", + "outputId": "b3f64b54-2263-42c5-fe4b-e0d40dad64b2" + }, + "execution_count": 24, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "WARNING:rasterio._env:CPLE_AppDefined in +init=epsg:XXXX syntax is deprecated. It might return a CRS with a non-EPSG compliant axis order.\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 24 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "!gdal_translate -of netCDF drive/MyDrive/landsat.tif drive/MyDrive/landsat.nc" + ], + "metadata": { + "id": "nITahHkqvtAM", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "91a55968-9eac-475d-eb50-8787a0af8e44" + }, + "execution_count": 29, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Input file size is 865, 669\n", + "0...10...20...30...40...50...60...70...80...90...100 - done.\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "!ls drive/MyDrive/landsat.nc" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "uAKeS44xGher", + "outputId": "ce844496-8c43-4fff-84a6-0ddeede478b4" + }, + "execution_count": 30, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "drive/MyDrive/landsat.nc\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "ds = xr.open_dataset('drive/MyDrive/landsat.nc')" + ], + "metadata": { + "id": "M88ze1AuOHh4" + }, + "execution_count": 32, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "ds" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 418 + }, + "id": "a5OmAb84OUYe", + "outputId": "93d0641f-91f2-4a2f-c7ec-d330617205b9" + }, + "execution_count": 33, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "\n", + "Dimensions: (lat: 669, lon: 865)\n", + "Coordinates:\n", + " * lat (lat) float64 39.75 39.75 39.75 39.75 ... 39.93 39.93 39.93 39.93\n", + " * lon (lon) float64 116.1 116.1 116.1 116.1 ... 116.4 116.4 116.4 116.4\n", + "Data variables:\n", + " crs |S1 ...\n", + " Band1 (lat, lon) float32 ...\n", + " Band2 (lat, lon) float32 ...\n", + " Band3 (lat, lon) float32 ...\n", + "Attributes:\n", + " GDAL_AREA_OR_POINT: Area\n", + " Conventions: CF-1.5\n", + " GDAL: GDAL 2.4.2, released 2019/06/28\n", + " history: Wed Aug 31 04:45:50 2022: GDAL CreateCopy( drive/MyD..." + ], + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset>\n",
+              "Dimensions:  (lat: 669, lon: 865)\n",
+              "Coordinates:\n",
+              "  * lat      (lat) float64 39.75 39.75 39.75 39.75 ... 39.93 39.93 39.93 39.93\n",
+              "  * lon      (lon) float64 116.1 116.1 116.1 116.1 ... 116.4 116.4 116.4 116.4\n",
+              "Data variables:\n",
+              "    crs      |S1 b''\n",
+              "    Band1    (lat, lon) float32 ...\n",
+              "    Band2    (lat, lon) float32 ...\n",
+              "    Band3    (lat, lon) float32 ...\n",
+              "Attributes:\n",
+              "    GDAL_AREA_OR_POINT:  Area\n",
+              "    Conventions:         CF-1.5\n",
+              "    GDAL:                GDAL 2.4.2, released 2019/06/28\n",
+              "    history:             Wed Aug 31 04:45:50 2022: GDAL CreateCopy( drive/MyD...
" + ] + }, + "metadata": {}, + "execution_count": 33 + } + ] + }, + { + "cell_type": "code", + "source": [ + "da.sel(band=1)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 527 + }, + "id": "sC55qc1_OU7L", + "outputId": "5c329514-9740-4e4d-c9b8-d9691c8c4709" + }, + "execution_count": 35, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "\n", + "array([[0.140429, 0.142585, 0.142585, ..., 0.149975, 0.149953, 0.151772],\n", + " [0.142114, 0.14838 , 0.14838 , ..., 0.147864, 0.155119, 0.160824],\n", + " [0.146943, 0.148919, 0.148919, ..., 0.151952, 0.146381, 0.158713],\n", + " ...,\n", + " [0.155006, 0.151547, 0.154175, ..., 0.188946, 0.199098, 0.199098],\n", + " [0.166664, 0.16763 , 0.165024, ..., 0.196987, 0.200154, 0.200154],\n", + " [0.188339, 0.170101, 0.166282, ..., 0.187665, 0.186138, 0.186138]],\n", + " dtype=float32)\n", + "Coordinates:\n", + " band int64 1\n", + " * y (y) float64 39.93 39.93 39.93 39.93 ... 39.75 39.75 39.75 39.75\n", + " * x (x) float64 116.1 116.1 116.1 116.1 ... 116.4 116.4 116.4 116.4\n", + " lon (y, x) float64 116.1 116.1 116.1 116.1 ... 116.4 116.4 116.4 116.4\n", + " lat (y, x) float64 39.93 39.93 39.93 39.93 ... 39.75 39.75 39.75 39.75\n", + "Attributes:\n", + " transform: (0.00026949458523585647, 0.0, 116.14569836660849, 0.0, -0...\n", + " crs: +init=epsg:4326\n", + " res: (0.00026949458523585647, 0.00026949458523585647)\n", + " is_tiled: 1\n", + " nodatavals: (nan, nan, nan)\n", + " scales: (1.0, 1.0, 1.0)\n", + " offsets: (0.0, 0.0, 0.0)\n", + " descriptions: ('B4', 'B3', 'B2')\n", + " AREA_OR_POINT: Area" + ], + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray (y: 669, x: 865)>\n",
+              "array([[0.140429, 0.142585, 0.142585, ..., 0.149975, 0.149953, 0.151772],\n",
+              "       [0.142114, 0.14838 , 0.14838 , ..., 0.147864, 0.155119, 0.160824],\n",
+              "       [0.146943, 0.148919, 0.148919, ..., 0.151952, 0.146381, 0.158713],\n",
+              "       ...,\n",
+              "       [0.155006, 0.151547, 0.154175, ..., 0.188946, 0.199098, 0.199098],\n",
+              "       [0.166664, 0.16763 , 0.165024, ..., 0.196987, 0.200154, 0.200154],\n",
+              "       [0.188339, 0.170101, 0.166282, ..., 0.187665, 0.186138, 0.186138]],\n",
+              "      dtype=float32)\n",
+              "Coordinates:\n",
+              "    band     int64 1\n",
+              "  * y        (y) float64 39.93 39.93 39.93 39.93 ... 39.75 39.75 39.75 39.75\n",
+              "  * x        (x) float64 116.1 116.1 116.1 116.1 ... 116.4 116.4 116.4 116.4\n",
+              "    lon      (y, x) float64 116.1 116.1 116.1 116.1 ... 116.4 116.4 116.4 116.4\n",
+              "    lat      (y, x) float64 39.93 39.93 39.93 39.93 ... 39.75 39.75 39.75 39.75\n",
+              "Attributes:\n",
+              "    transform:      (0.00026949458523585647, 0.0, 116.14569836660849, 0.0, -0...\n",
+              "    crs:            +init=epsg:4326\n",
+              "    res:            (0.00026949458523585647, 0.00026949458523585647)\n",
+              "    is_tiled:       1\n",
+              "    nodatavals:     (nan, nan, nan)\n",
+              "    scales:         (1.0, 1.0, 1.0)\n",
+              "    offsets:        (0.0, 0.0, 0.0)\n",
+              "    descriptions:   ('B4', 'B3', 'B2')\n",
+              "    AREA_OR_POINT:  Area
" + ] + }, + "metadata": {}, + "execution_count": 35 + } + ] + }, + { + "cell_type": "code", + "source": [ + "ds.Band1.values" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ckwzSoqxOZZh", + "outputId": "ded9d407-a0f1-46e1-89be-65883bd19451" + }, + "execution_count": 37, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[0.18833928, 0.17010057, 0.16628213, ..., 0.18766543, 0.18613805,\n", + " 0.18613805],\n", + " [0.16666397, 0.16762981, 0.16502428, ..., 0.19698693, 0.20015399,\n", + " 0.20015399],\n", + " [0.15500648, 0.15154742, 0.1541754 , ..., 0.18894573, 0.1990983 ,\n", + " 0.1990983 ],\n", + " ...,\n", + " [0.14694281, 0.14891942, 0.14891942, ..., 0.15195172, 0.14638127,\n", + " 0.15871261],\n", + " [0.1421136 , 0.14838035, 0.14838035, ..., 0.14786373, 0.15511878,\n", + " 0.16082399],\n", + " [0.14042899, 0.14258529, 0.14258529, ..., 0.1499751 , 0.14995265,\n", + " 0.15177202]], dtype=float32)" + ] + }, + "metadata": {}, + "execution_count": 37 + } + ] + }, + { + "cell_type": "code", + "source": [ + "ds.Band1.plot()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 298 + }, + "id": "s7zmzvQSOhT6", + "outputId": "4d7e521b-d6c7-44aa-a50a-2b8ca9f79f53" + }, + "execution_count": 38, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 38 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "!gdal_translate NETCDF:\"drive/MyDrive/landsat.nc\":Band1 landsat_from_nc.tif" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "k2vc59rzYr5Q", + "outputId": "9fa6ee83-f8e7-4bc6-98e0-d7d77ecf6a92" + }, + "execution_count": 39, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Input file size is 865, 669\n", + "0...10...20...30...40...50...60...70...80...90...100 - done.\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "!ls" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "-9kJxeT6e_7g", + "outputId": "99b34e12-fac8-4b4f-fb8d-91e9f9bb737e" + }, + "execution_count": 40, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Anaconda3-2020.02-Linux-x86_64.sh drive\t\t sample_data\n", + "Anaconda3-2020.02-Linux-x86_64.sh.1 landsat_from_nc.tif\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "da = xr.open_rasterio(\"landsat_from_nc.tif\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NHCN6GNFfA-j", + "outputId": "212c7b23-d49e-4f2a-8e98-c683c347e7eb" + }, + "execution_count": 41, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:1: DeprecationWarning: open_rasterio is Deprecated in favor of rioxarray. For information about transitioning, see: https://corteva.github.io/rioxarray/stable/getting_started/getting_started.html\n", + " \"\"\"Entry point for launching an IPython kernel.\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "da.values" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Y3E4CljqfKjE", + "outputId": "9456adfa-f094-422b-8cfc-02e36881581d" + }, + "execution_count": 44, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([[[0.14042899, 0.14258529, 0.14258529, ..., 0.1499751 ,\n", + " 0.14995265, 0.15177202],\n", + " [0.1421136 , 0.14838035, 0.14838035, ..., 0.14786373,\n", + " 0.15511878, 0.16082399],\n", + " [0.14694281, 0.14891942, 0.14891942, ..., 0.15195172,\n", + " 0.14638127, 0.15871261],\n", + " ...,\n", + " [0.15500648, 0.15154742, 0.1541754 , ..., 0.18894573,\n", + " 0.1990983 , 0.1990983 ],\n", + " [0.16666397, 0.16762981, 0.16502428, ..., 0.19698693,\n", + " 0.20015399, 0.20015399],\n", + " [0.18833928, 0.17010057, 0.16628213, ..., 0.18766543,\n", + " 0.18613805, 0.18613805]]], dtype=float32)" + ] + }, + "metadata": {}, + "execution_count": 44 + } + ] + }, + { + "cell_type": "code", + "source": [ + "cloudImage = ee.Image.loadGeoTIFF(\"landsat_from_nc.tif\")" + ], + "metadata": { + "id": "GBaPw7LHfOiY" + }, + "execution_count": 45, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "cloudImage" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "oT2VWo9ngUq6", + "outputId": "d65ef352-640f-4cd4-c3e5-f7a3316510ae" + }, + "execution_count": 46, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 46 + } + ] + }, + { + "cell_type": "code", + "source": [ + "#!conda install -c conda-forge pyproj\n", + "!conda install https://anaconda.org/conda-forge/pyproj/3.3.1/download/linux-aarch64/pyproj-3.3.1-py38h4a6e2e3_1.tar.bz2" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "HtnGU0emhkoS", + "outputId": "2da924e4-ba34-4fda-fe13-83155ad6044f" + }, + "execution_count": 51, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "Downloading and Extracting Packages\n", + "pyproj-3.3.1 | : 100% 1.0/1 [00:00<00:00, 1.12it/s]\n", + "Preparing transaction: - \b\bdone\n", + "Verifying transaction: | \b\bdone\n", + "Executing transaction: - \b\bdone\n", + "Retrieving notices: ...working... done\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# !apt-get install libgeos-3.5.0\n", + "# !apt-get install libgeos-dev\n", + "#!pip install https://github.com/matplotlib/basemap/archive/master.zip" + ], + "metadata": { + "id": "_tlD7R87lYKW" + }, + "execution_count": 57, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "!pip install pyproj" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "n7FZYGt5l5W-", + "outputId": "42049956-810e-4861-d217-fb8b06a7bbb2" + }, + "execution_count": 61, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Collecting pyproj\n", + " Downloading pyproj-3.2.1-cp37-cp37m-manylinux2010_x86_64.whl (6.3 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m6.3/6.3 MB\u001b[0m \u001b[31m40.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: certifi in /usr/local/lib/python3.7/site-packages (from pyproj) (2019.11.28)\n", + "Installing collected packages: pyproj\n", + "Successfully installed pyproj-3.2.1\n", + "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[0m" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import xarray as xr\n", + "import numpy as np\n", + "import folium\n", + "from cartopy.img_transform import warp_array\n", + "import cartopy.crs as ccrs\n", + "import matplotlib.cm\n", + "\n", + "data = ds.Band1\n", + "data2plot = np.flipud(data.values.astype(np.float64))\n", + "\n", + "lon, lat = np.meshgrid(data.lon.values.astype(np.float64), data.lat.values.astype(np.float64))\n", + "source_extent = [lon.min(), lon.max(), lat.min(), lat.max()]\n", + "normed_data = (data2plot - np.nanmin(data2plot)) / (np.nanmax(data2plot) - np.nanmin(data2plot))\n", + "\n", + "\n", + "cm = matplotlib.cm.get_cmap('cubehelix')\n", + "colored_data = cm(normed_data)\n", + "\n", + "m = folium.Map(location=[lat.mean(), lon.mean()], zoom_start=10)\n", + "folium.raster_layers.ImageOverlay(colored_data,\n", + " [[lat.min(), lon.min()], [lat.max(), lon.max()]],\n", + " mercator_project=True,\n", + " opacity=0.5).add_to(m)\n", + "m\n", + "#m.save('test_xarray_folium.html')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 719 + }, + "id": "CQNCyjOdglId", + "outputId": "b143bb2c-820e-4af4-e829-8b2b5231c120" + }, + "execution_count": 66, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "
Make this Notebook Trusted to load map: File -> Trust Notebook
" + ] + }, + "metadata": {}, + "execution_count": 66 + } + ] + }, + { + "cell_type": "code", + "source": [ + "import io\n", + "from PIL import Image\n", + "\n", + "img_data = m._to_png(5) # time to render the map\n", + "img = Image.open(io.BytesIO(img_data))\n", + "img.save('image.png')" + ], + "metadata": { + "id": "0LvGdUAngwyc" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file From dda3ba4acf02ab01f9b70bbad3fe0a19429821f6 Mon Sep 17 00:00:00 2001 From: Manmeet Singh Date: Sat, 3 Sep 2022 01:09:30 -0700 Subject: [PATCH 09/14] Created using Colaboratory --- gee/gedi_extract_clean.ipynb | 237 +++++++++++++++++++++++++++++++++++ 1 file changed, 237 insertions(+) create mode 100644 gee/gedi_extract_clean.ipynb diff --git a/gee/gedi_extract_clean.ipynb b/gee/gedi_extract_clean.ipynb new file mode 100644 index 0000000..a3616dd --- /dev/null +++ b/gee/gedi_extract_clean.ipynb @@ -0,0 +1,237 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "collapsed_sections": [], + "authorship_tag": "ABX9TyN8LQadU432/Xt+pUWcjRvS", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "2Dz53glqYYtk" + }, + "outputs": [], + "source": [ + "from google.colab import auth\n", + "auth.authenticate_user()" + ] + }, + { + "cell_type": "code", + "source": [ + "from google.colab import drive\n", + "drive.mount('/content/drive')" + ], + "metadata": { + "id": "UC_1YbNWYeac" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "import ee, folium" + ], + "metadata": { + "id": "NWmlYMuFYgYa" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "import ee\n", + "ee.Authenticate()\n", + "ee.Initialize()" + ], + "metadata": { + "id": "i0UzjKNZYmVq" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "!sudo add-apt-repository ppa:ubuntugis/ppa\n", + "!sudo apt-get update\n", + "!sudo apt-get install gdal-bin libgdal-dev\n", + "!pip install -U pip\n", + "!pip install rasterio" + ], + "metadata": { + "id": "IVNG3snKYn-n" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "try:\n", + " import geopandas as gpd\n", + " import shapefile\n", + " from osgeo import ogr,osr,gdal\n", + "except:\n", + " !pip install geopandas\n", + " !pip install PyShp\n", + " !pip install gdal\n", + "import geopandas as gpd\n", + "import shapefile\n", + "import numpy as np\n", + "import os\n", + "import time\n", + "from osgeo import ogr,osr,gdal\n", + "import tensorflow as tf" + ], + "metadata": { + "id": "KgpZR6Y9Ypvb" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def qualityMask(im):\n", + " return im.updateMask(im.select('quality_flag').eq(1)).updateMask(im.select('degrade_flag').eq(0))\n", + "dataset = ee.ImageCollection('LARSE/GEDI/GEDI02_A_002_MONTHLY').map(qualityMask).select('rh98')" + ], + "metadata": { + "id": "8VNcBhx8YsmN" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "visualization = {\n", + " 'min': 1.0,\n", + " 'max': 60.0,\n", + " 'palette': ['darkred','red','orange','green','darkgreen']\n", + " #'bands': ['B4', 'B3', 'B2'],\n", + "}\n", + "\n", + "map = folium.Map(location=[1.64, 110.20],zoom_start=4, height=1000,width=1500)\n", + "mapid = dataset.get(100).getMapId(visualization)\n", + "folium.TileLayer(\n", + " tiles=mapid['tile_fetcher'].url_format,\n", + " attr='Map Data © Google Earth Engine',\n", + " overlay=True,\n", + " name='GEDI',\n", + " opacity=0.5,\n", + " ).add_to(map)\n", + "\n", + "map.add_child(folium.LayerControl())\n", + "title_html = '''\n", + "

'GEDI RH98'

\n", + " '''\n", + "map.get_root().html.add_child(folium.Element(title_html))\n", + "map" + ], + "metadata": { + "id": "pq884v0BYwch" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "aoi = ee.Geometry.Polygon(\n", + " [[[10.752981103928594, 0.7627966289396413],\n", + " [10.752981103928594, -0.7615114430026542],\n", + " [13.104055322678594, -0.7615114430026542],\n", + " [13.104055322678594, 0.7627966289396413]]], np.nan, False)" + ], + "metadata": { + "id": "OQCimRqSYy7i" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "#// GEDI pre-processing\n", + "def func_(image):\n", + " return image.updateMask(image.select('sensitivity').gt(0.98)).updateMask(image.select('quality_flag').eq(1)).updateMask(image.select('degrade_flag').eq(0)).select('rh100').toInt()\n", + "\n", + "gedi = ee.ImageCollection('LARSE/GEDI/GEDI02_A_002_MONTHLY').filterBounds(aoi).map(func_)" + ], + "metadata": { + "id": "mvep2QIYY4Dj" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "projection = gedi.first().projection().aside(print)\n", + "scale = projection.nominalScale().aside(print)\n", + "mosaic = gedi.mosaic().setDefaultProjection(crs=projection, scale=scale)\n", + "mosaicMask = mosaic.lt(60)\n", + "mosaic = mosaic.updateMask(mosaicMask)\n", + "#//print(mosaic) \n", + "\n", + "\n", + "referenceData = mosaic.reduceToVectors(geometry = aoi,\n", + " geometryType= 'polygon',\n", + " scale = scale,\n", + " maxPixels = 100e9,\n", + " tileScale=16,\n", + " crs = projection,\n", + " )" + ], + "metadata": { + "id": "ssLR8tFhY6j8" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "task = ee.batch.Export.table.toDrive(\n", + " collection= referenceData,\n", + " folder= 'gedi',\n", + " description='referenceData',\n", + " fileFormat= 'SHP'\n", + ")\n", + "task.start()" + ], + "metadata": { + "id": "HkLalRZrY9Fl" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file From 11a7cd353a8a4325bd5488ded8a48555ee8ff72a Mon Sep 17 00:00:00 2001 From: Manmeet Singh Date: Sat, 3 Sep 2022 01:13:47 -0700 Subject: [PATCH 10/14] Created using Colaboratory --- gee/gedi_extract_clean.ipynb | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/gee/gedi_extract_clean.ipynb b/gee/gedi_extract_clean.ipynb index a3616dd..66b3776 100644 --- a/gee/gedi_extract_clean.ipynb +++ b/gee/gedi_extract_clean.ipynb @@ -5,7 +5,7 @@ "colab": { "provenance": [], "collapsed_sections": [], - "authorship_tag": "ABX9TyN8LQadU432/Xt+pUWcjRvS", + "authorship_tag": "ABX9TyP095NtV3XLN37rxfJUz1F5", "include_colab_link": true }, "kernelspec": { @@ -27,6 +27,17 @@ "\"Open" ] }, + { + "cell_type": "markdown", + "source": [ + "Raster to vector: https://gis.stackexchange.com/questions/434001/fixingfeaturecollection-error-image-reducetovectors-first-band-rh100-of\n", + "\n", + "After running this script for your region of interest go to the task manager (https://code.earthengine.google.com/tasks) to check if the data has been downloaded to the Google Drive" + ], + "metadata": { + "id": "v3-quoXFZ5A_" + } + }, { "cell_type": "code", "execution_count": null, From 74cdd1287e6384423934a2433e3dfeef39b87c1f Mon Sep 17 00:00:00 2001 From: Manmeet Singh Date: Sat, 3 Sep 2022 05:55:03 -0700 Subject: [PATCH 11/14] Created using Colaboratory --- gee/gedi_extract_clean.ipynb | 1148 +++++++++++++++++++++++++++++++++- 1 file changed, 1126 insertions(+), 22 deletions(-) diff --git a/gee/gedi_extract_clean.ipynb b/gee/gedi_extract_clean.ipynb index 66b3776..fa03206 100644 --- a/gee/gedi_extract_clean.ipynb +++ b/gee/gedi_extract_clean.ipynb @@ -5,7 +5,7 @@ "colab": { "provenance": [], "collapsed_sections": [], - "authorship_tag": "ABX9TyP095NtV3XLN37rxfJUz1F5", + "authorship_tag": "ABX9TyOMVBTxFu8VJvYzCgiN7/77", "include_colab_link": true }, "kernelspec": { @@ -40,7 +40,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": { "id": "2Dz53glqYYtk" }, @@ -57,10 +57,22 @@ "drive.mount('/content/drive')" ], "metadata": { - "id": "UC_1YbNWYeac" + "id": "UC_1YbNWYeac", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "0d458977-1b3a-418c-a7b2-6faaac9bb9e0" }, - "execution_count": null, - "outputs": [] + "execution_count": 6, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Mounted at /content/drive\n" + ] + } + ] }, { "cell_type": "code", @@ -70,7 +82,7 @@ "metadata": { "id": "NWmlYMuFYgYa" }, - "execution_count": null, + "execution_count": 22, "outputs": [] }, { @@ -81,10 +93,29 @@ "ee.Initialize()" ], "metadata": { - "id": "i0UzjKNZYmVq" + "id": "i0UzjKNZYmVq", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "46c8b54c-611a-44ad-8b14-b548d73783e1" }, - "execution_count": null, - "outputs": [] + "execution_count": 23, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "To authorize access needed by Earth Engine, open the following URL in a web browser and follow the instructions. If the web browser does not start automatically, please manually browse the URL below.\n", + "\n", + " https://code.earthengine.google.com/client-auth?scopes=https%3A//www.googleapis.com/auth/earthengine%20https%3A//www.googleapis.com/auth/devstorage.full_control&request_id=IcMhUnKFfobhi1-PHcEuk6J7jr9waRAGwz54msjowoY&tc=4bl0iM9mEvEXJ1sFKcS3NPGRW6218GkbLvnhhbhV3Xo&cc=bLt034zwlaZVF0TGB-4MANfxQfdL7hu67y9vXvrBPWk\n", + "\n", + "The authorization workflow will generate a code, which you should paste in the box below.\n", + "Enter verification code: 4/1AdQt8qjLBV72ldhuBiOaoSckFTOA_phVHjTHPViL5XiuKVEwJOtTOXt7KBI\n", + "\n", + "Successfully saved authorization token.\n" + ] + } + ] }, { "cell_type": "code", @@ -96,10 +127,370 @@ "!pip install rasterio" ], "metadata": { - "id": "IVNG3snKYn-n" + "id": "IVNG3snKYn-n", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "1b6eb3e0-f711-40f2-f31d-6ca031801a56" }, - "execution_count": null, - "outputs": [] + "execution_count": 24, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " Official stable UbuntuGIS packages.\n", + "\n", + "\n", + " More info: https://launchpad.net/~ubuntugis/+archive/ubuntu/ppa\n", + "Press [ENTER] to continue or Ctrl-c to cancel adding it.\n", + "\n", + "Get:1 https://cloud.r-project.org/bin/linux/ubuntu bionic-cran40/ InRelease [3,626 B]\n", + "Ign:2 https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64 InRelease\n", + "Hit:3 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64 InRelease\n", + "Hit:4 https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64 Release\n", + "Hit:5 http://ppa.launchpad.net/c2d4u.team/c2d4u4.0+/ubuntu bionic InRelease\n", + "Hit:7 http://archive.ubuntu.com/ubuntu bionic InRelease\n", + "Get:8 http://security.ubuntu.com/ubuntu bionic-security InRelease [88.7 kB]\n", + "Get:9 http://archive.ubuntu.com/ubuntu bionic-updates InRelease [88.7 kB]\n", + "Hit:10 http://ppa.launchpad.net/cran/libgit2/ubuntu bionic InRelease\n", + "Hit:11 http://ppa.launchpad.net/deadsnakes/ppa/ubuntu bionic InRelease\n", + "Get:12 http://archive.ubuntu.com/ubuntu bionic-backports InRelease [74.6 kB]\n", + "Get:13 http://security.ubuntu.com/ubuntu bionic-security/restricted amd64 Packages [1,121 kB]\n", + "Get:14 http://archive.ubuntu.com/ubuntu bionic-updates/main amd64 Packages [3,390 kB]\n", + "Hit:15 http://ppa.launchpad.net/graphics-drivers/ppa/ubuntu bionic InRelease\n", + "Get:16 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic InRelease [20.7 kB]\n", + "Get:17 http://archive.ubuntu.com/ubuntu bionic-updates/restricted amd64 Packages [1,162 kB]\n", + "Get:18 http://security.ubuntu.com/ubuntu bionic-security/universe amd64 Packages [1,540 kB]\n", + "Get:19 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 Packages [69.1 kB]\n", + "Get:20 http://security.ubuntu.com/ubuntu bionic-security/main amd64 Packages [2,959 kB]\n", + "Fetched 10.5 MB in 4s (2,889 kB/s)\n", + "Reading package lists... Done\n", + "Hit:1 https://cloud.r-project.org/bin/linux/ubuntu bionic-cran40/ InRelease\n", + "Hit:2 http://archive.ubuntu.com/ubuntu bionic InRelease\n", + "Ign:3 https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64 InRelease\n", + "Hit:4 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64 InRelease\n", + "Hit:5 https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64 Release\n", + "Hit:6 http://ppa.launchpad.net/c2d4u.team/c2d4u4.0+/ubuntu bionic InRelease\n", + "Hit:7 http://security.ubuntu.com/ubuntu bionic-security InRelease\n", + "Hit:8 http://archive.ubuntu.com/ubuntu bionic-updates InRelease\n", + "Hit:10 http://archive.ubuntu.com/ubuntu bionic-backports InRelease\n", + "Hit:11 http://ppa.launchpad.net/cran/libgit2/ubuntu bionic InRelease\n", + "Hit:12 http://ppa.launchpad.net/deadsnakes/ppa/ubuntu bionic InRelease\n", + "Hit:13 http://ppa.launchpad.net/graphics-drivers/ppa/ubuntu bionic InRelease\n", + "Hit:14 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic InRelease\n", + "Reading package lists... Done\n", + "Reading package lists... Done\n", + "Building dependency tree \n", + "Reading state information... Done\n", + "The following package was automatically installed and is no longer required:\n", + " libnvidia-common-460\n", + "Use 'sudo apt autoremove' to remove it.\n", + "The following additional packages will be installed:\n", + " gdal-data libcharls-dev libgdal20 libogdi-dev libogdi4.1\n", + " libopencv-calib3d-dev libopencv-calib3d3.2 libopencv-contrib-dev\n", + " libopencv-contrib3.2 libopencv-core-dev libopencv-core3.2 libopencv-dev\n", + " libopencv-features2d-dev libopencv-features2d3.2 libopencv-flann-dev\n", + " libopencv-flann3.2 libopencv-highgui-dev libopencv-highgui3.2\n", + " libopencv-imgcodecs-dev libopencv-imgcodecs3.2 libopencv-imgproc-dev\n", + " libopencv-imgproc3.2 libopencv-ml-dev libopencv-ml3.2\n", + " libopencv-objdetect-dev libopencv-objdetect3.2 libopencv-photo-dev\n", + " libopencv-photo3.2 libopencv-shape-dev libopencv-shape3.2\n", + " libopencv-stitching-dev libopencv-stitching3.2 libopencv-superres-dev\n", + " libopencv-superres3.2 libopencv-ts-dev libopencv-video-dev\n", + " libopencv-video3.2 libopencv-videoio-dev libopencv-videoio3.2\n", + " libopencv-videostab-dev libopencv-videostab3.2 libopencv-viz-dev\n", + " libopencv-viz3.2 libopencv3.2-java libopencv3.2-jni libproj13 libvtk6.3\n", + " libzstd-dev python-gdal\n", + "Suggested packages:\n", + " libgdal-grass libgdal-doc ogdi-bin opencv-doc proj-bin vtk6-doc\n", + " vtk6-examples\n", + "Recommended packages:\n", + " proj-bin opencv-data\n", + "The following packages will be REMOVED:\n", + " libogdi3.2 libogdi3.2-dev\n", + "The following NEW packages will be installed:\n", + " libcharls-dev libogdi-dev libogdi4.1 libproj13 libzstd-dev\n", + "The following packages will be upgraded:\n", + " gdal-bin gdal-data libgdal-dev libgdal20 libopencv-calib3d-dev\n", + " libopencv-calib3d3.2 libopencv-contrib-dev libopencv-contrib3.2\n", + " libopencv-core-dev libopencv-core3.2 libopencv-dev libopencv-features2d-dev\n", + " libopencv-features2d3.2 libopencv-flann-dev libopencv-flann3.2\n", + " libopencv-highgui-dev libopencv-highgui3.2 libopencv-imgcodecs-dev\n", + " libopencv-imgcodecs3.2 libopencv-imgproc-dev libopencv-imgproc3.2\n", + " libopencv-ml-dev libopencv-ml3.2 libopencv-objdetect-dev\n", + " libopencv-objdetect3.2 libopencv-photo-dev libopencv-photo3.2\n", + " libopencv-shape-dev libopencv-shape3.2 libopencv-stitching-dev\n", + " libopencv-stitching3.2 libopencv-superres-dev libopencv-superres3.2\n", + " libopencv-ts-dev libopencv-video-dev libopencv-video3.2\n", + " libopencv-videoio-dev libopencv-videoio3.2 libopencv-videostab-dev\n", + " libopencv-videostab3.2 libopencv-viz-dev libopencv-viz3.2 libopencv3.2-java\n", + " libopencv3.2-jni libvtk6.3 python-gdal\n", + "46 upgraded, 5 newly installed, 2 to remove and 33 not upgraded.\n", + "Need to get 60.8 MB of archives.\n", + "After this operation, 14.4 MB of additional disk space will be used.\n", + "Get:1 http://archive.ubuntu.com/ubuntu bionic/universe amd64 libcharls-dev amd64 1.1.0+dfsg-2 [20.4 kB]\n", + "Get:2 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-dev amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [237 kB]\n", + "Get:3 http://archive.ubuntu.com/ubuntu bionic-updates/main amd64 libzstd-dev amd64 1.3.3+dfsg-2ubuntu1.2 [230 kB]\n", + "Get:4 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-ts-dev amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [279 kB]\n", + "Get:5 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-contrib-dev amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [1,878 kB]\n", + "Get:6 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-videostab-dev amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [135 kB]\n", + "Get:7 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-stitching-dev amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [222 kB]\n", + "Get:8 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-calib3d-dev amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [516 kB]\n", + "Get:9 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-features2d-dev amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [293 kB]\n", + "Get:10 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-flann-dev amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [176 kB]\n", + "Get:11 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-contrib3.2 amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [1,464 kB]\n", + "Get:12 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv3.2-jni amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [201 kB]\n", + "Get:13 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-videostab3.2 amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [111 kB]\n", + "Get:14 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-stitching3.2 amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [179 kB]\n", + "Get:15 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-calib3d3.2 amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [440 kB]\n", + "Get:16 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-features2d3.2 amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [244 kB]\n", + "Get:17 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-flann3.2 amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [105 kB]\n", + "Get:18 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-objdetect-dev amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [176 kB]\n", + "Get:19 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-objdetect3.2 amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [151 kB]\n", + "Get:20 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-ml-dev amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [297 kB]\n", + "Get:21 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-ml3.2 amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [236 kB]\n", + "Get:22 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-superres-dev amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [65.7 kB]\n", + "Get:23 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-highgui-dev amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [44.3 kB]\n", + "Get:24 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-videoio-dev amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [124 kB]\n", + "Get:25 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-imgcodecs-dev amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [132 kB]\n", + "Get:26 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-superres3.2 amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [55.9 kB]\n", + "Get:27 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-highgui3.2 amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [32.3 kB]\n", + "Get:28 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-videoio3.2 amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [90.9 kB]\n", + "Get:29 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-viz-dev amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [163 kB]\n", + "Get:30 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-shape-dev amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [84.0 kB]\n", + "Get:31 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-video-dev amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [162 kB]\n", + "Get:32 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-photo-dev amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [238 kB]\n", + "Get:33 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-imgproc-dev amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [1,023 kB]\n", + "Get:34 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-core-dev amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [1,108 kB]\n", + "Get:35 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libproj13 amd64 5.2.0-1~bionic0 [202 kB]\n", + "Get:36 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libvtk6.3 amd64 6.3.0+dfsg2-2build4~bionic2 [31.4 MB]\n", + "Get:37 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-viz3.2 amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [124 kB]\n", + "Get:38 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-shape3.2 amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [69.7 kB]\n", + "Get:39 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-video3.2 amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [136 kB]\n", + "Get:40 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-photo3.2 amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [203 kB]\n", + "Get:41 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-imgcodecs3.2 amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [95.8 kB]\n", + "Get:42 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-imgproc3.2 amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [831 kB]\n", + "Get:43 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv-core3.2 amd64 3.2.0+dfsg-4ubuntu0.1+bionic2 [720 kB]\n", + "Get:44 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libopencv3.2-java all 3.2.0+dfsg-4ubuntu0.1+bionic2 [401 kB]\n", + "Get:45 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 python-gdal amd64 2.4.2+dfsg-1~bionic0 [809 kB]\n", + "Get:46 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 gdal-bin amd64 2.4.2+dfsg-1~bionic0 [408 kB]\n", + "Get:47 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 gdal-data all 2.4.2+dfsg-1~bionic0 [749 kB]\n", + "Get:48 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libgdal-dev amd64 2.4.2+dfsg-1~bionic0 [7,493 kB]\n", + "Get:49 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libogdi4.1 amd64 4.1.0+ds-1~bionic0 [199 kB]\n", + "Get:50 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libgdal20 amd64 2.4.2+dfsg-1~bionic0 [6,033 kB]\n", + "Get:51 http://ppa.launchpad.net/ubuntugis/ppa/ubuntu bionic/main amd64 libogdi-dev amd64 4.1.0+ds-1~bionic0 [25.4 kB]\n", + "Fetched 60.8 MB in 1min 6s (916 kB/s)\n", + "debconf: unable to initialize frontend: Dialog\n", + "debconf: (No usable dialog-like program is installed, so the dialog based frontend cannot be used. at /usr/share/perl5/Debconf/FrontEnd/Dialog.pm line 76, <> line 51.)\n", + "debconf: falling back to frontend: Readline\n", + "debconf: unable to initialize frontend: Readline\n", + "debconf: (This frontend requires a controlling tty.)\n", + "debconf: falling back to frontend: Teletype\n", + "dpkg-preconfigure: unable to re-open stdin: \n", + "(Reading database ... 155685 files and directories currently installed.)\n", + "Preparing to unpack .../00-libopencv-dev_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-dev (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../01-libopencv-ts-dev_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-ts-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../02-libopencv-contrib-dev_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-contrib-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../03-libopencv-videostab-dev_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-videostab-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../04-libopencv-stitching-dev_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-stitching-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../05-libopencv-calib3d-dev_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-calib3d-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../06-libopencv-features2d-dev_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-features2d-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../07-libopencv-flann-dev_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-flann-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../08-libopencv-contrib3.2_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-contrib3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../09-libopencv3.2-jni_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv3.2-jni (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../10-libopencv-videostab3.2_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-videostab3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../11-libopencv-stitching3.2_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-stitching3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../12-libopencv-calib3d3.2_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-calib3d3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../13-libopencv-features2d3.2_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-features2d3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../14-libopencv-flann3.2_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-flann3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../15-libopencv-objdetect-dev_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-objdetect-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../16-libopencv-objdetect3.2_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-objdetect3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../17-libopencv-ml-dev_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-ml-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../18-libopencv-ml3.2_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-ml3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../19-libopencv-superres-dev_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-superres-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../20-libopencv-highgui-dev_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-highgui-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../21-libopencv-videoio-dev_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-videoio-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../22-libopencv-imgcodecs-dev_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-imgcodecs-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../23-libopencv-superres3.2_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-superres3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../24-libopencv-highgui3.2_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-highgui3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../25-libopencv-videoio3.2_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-videoio3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../26-libopencv-viz-dev_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-viz-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../27-libopencv-shape-dev_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-shape-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../28-libopencv-video-dev_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-video-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../29-libopencv-photo-dev_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-photo-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../30-libopencv-imgproc-dev_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-imgproc-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../31-libopencv-core-dev_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-core-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Selecting previously unselected package libproj13:amd64.\n", + "Preparing to unpack .../32-libproj13_5.2.0-1~bionic0_amd64.deb ...\n", + "Unpacking libproj13:amd64 (5.2.0-1~bionic0) ...\n", + "Preparing to unpack .../33-libvtk6.3_6.3.0+dfsg2-2build4~bionic2_amd64.deb ...\n", + "Unpacking libvtk6.3 (6.3.0+dfsg2-2build4~bionic2) over (6.3.0+dfsg1-11build1) ...\n", + "Preparing to unpack .../34-libopencv-viz3.2_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-viz3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../35-libopencv-shape3.2_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-shape3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../36-libopencv-video3.2_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-video3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../37-libopencv-photo3.2_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-photo3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../38-libopencv-imgcodecs3.2_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-imgcodecs3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../39-libopencv-imgproc3.2_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-imgproc3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../40-libopencv-core3.2_3.2.0+dfsg-4ubuntu0.1+bionic2_amd64.deb ...\n", + "Unpacking libopencv-core3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../41-libopencv3.2-java_3.2.0+dfsg-4ubuntu0.1+bionic2_all.deb ...\n", + "Unpacking libopencv3.2-java (3.2.0+dfsg-4ubuntu0.1+bionic2) over (3.2.0+dfsg-4ubuntu0.1) ...\n", + "Preparing to unpack .../42-python-gdal_2.4.2+dfsg-1~bionic0_amd64.deb ...\n", + "Unpacking python-gdal (2.4.2+dfsg-1~bionic0) over (2.2.3+dfsg-2) ...\n", + "Preparing to unpack .../43-gdal-bin_2.4.2+dfsg-1~bionic0_amd64.deb ...\n", + "Unpacking gdal-bin (2.4.2+dfsg-1~bionic0) over (2.2.3+dfsg-2) ...\n", + "Preparing to unpack .../44-gdal-data_2.4.2+dfsg-1~bionic0_all.deb ...\n", + "Unpacking gdal-data (2.4.2+dfsg-1~bionic0) over (2.2.3+dfsg-2) ...\n", + "Preparing to unpack .../45-libgdal-dev_2.4.2+dfsg-1~bionic0_amd64.deb ...\n", + "Unpacking libgdal-dev (2.4.2+dfsg-1~bionic0) over (2.2.3+dfsg-2) ...\n", + "(Reading database ... 155698 files and directories currently installed.)\n", + "Removing libogdi3.2-dev (3.2.0+ds-2) ...\n", + "dpkg: libogdi3.2: dependency problems, but removing anyway as you requested:\n", + " libgdal20 depends on libogdi3.2 (>= 3.2.0); however:\n", + " Package libogdi3.2 is to be removed.\n", + "\n", + "Removing libogdi3.2 (3.2.0+ds-2) ...\n", + "Selecting previously unselected package libogdi4.1.\n", + "(Reading database ... 155667 files and directories currently installed.)\n", + "Preparing to unpack .../libogdi4.1_4.1.0+ds-1~bionic0_amd64.deb ...\n", + "Unpacking libogdi4.1 (4.1.0+ds-1~bionic0) ...\n", + "Preparing to unpack .../libgdal20_2.4.2+dfsg-1~bionic0_amd64.deb ...\n", + "Unpacking libgdal20 (2.4.2+dfsg-1~bionic0) over (2.2.3+dfsg-2) ...\n", + "Selecting previously unselected package libcharls-dev:amd64.\n", + "Preparing to unpack .../libcharls-dev_1.1.0+dfsg-2_amd64.deb ...\n", + "Unpacking libcharls-dev:amd64 (1.1.0+dfsg-2) ...\n", + "Selecting previously unselected package libogdi-dev.\n", + "Preparing to unpack .../libogdi-dev_4.1.0+ds-1~bionic0_amd64.deb ...\n", + "Unpacking libogdi-dev (4.1.0+ds-1~bionic0) ...\n", + "Selecting previously unselected package libzstd-dev:amd64.\n", + "Preparing to unpack .../libzstd-dev_1.3.3+dfsg-2ubuntu1.2_amd64.deb ...\n", + "Unpacking libzstd-dev:amd64 (1.3.3+dfsg-2ubuntu1.2) ...\n", + "Setting up libopencv-core3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libproj13:amd64 (5.2.0-1~bionic0) ...\n", + "Setting up gdal-data (2.4.2+dfsg-1~bionic0) ...\n", + "Setting up libcharls-dev:amd64 (1.1.0+dfsg-2) ...\n", + "Setting up libopencv-core-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libzstd-dev:amd64 (1.3.3+dfsg-2ubuntu1.2) ...\n", + "Setting up libogdi4.1 (4.1.0+ds-1~bionic0) ...\n", + "Setting up libopencv-ml3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libopencv-ml-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libopencv-imgproc3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libopencv-flann3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libopencv-video3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libopencv-imgproc-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libopencv-photo3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libopencv-ts-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libogdi-dev (4.1.0+ds-1~bionic0) ...\n", + "Setting up libopencv-photo-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libgdal20 (2.4.2+dfsg-1~bionic0) ...\n", + "Setting up libopencv-flann-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libopencv-imgcodecs3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libvtk6.3 (6.3.0+dfsg2-2build4~bionic2) ...\n", + "Setting up python-gdal (2.4.2+dfsg-1~bionic0) ...\n", + "Setting up libopencv-shape3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libopencv-video-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up gdal-bin (2.4.2+dfsg-1~bionic0) ...\n", + "Setting up libopencv-videoio3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libopencv-shape-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libgdal-dev (2.4.2+dfsg-1~bionic0) ...\n", + "Setting up libopencv-imgcodecs-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libopencv-viz3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libopencv-superres3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libopencv-highgui3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libopencv-videoio-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libopencv-viz-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libopencv-objdetect3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libopencv-highgui-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libopencv-features2d3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libopencv-superres-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libopencv-features2d-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libopencv-calib3d3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libopencv-stitching3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libopencv-calib3d-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libopencv-objdetect-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libopencv-videostab3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libopencv-stitching-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libopencv-contrib3.2:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libopencv-videostab-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libopencv-contrib-dev:amd64 (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libopencv3.2-jni (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libopencv3.2-java (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Setting up libopencv-dev (3.2.0+dfsg-4ubuntu0.1+bionic2) ...\n", + "Processing triggers for man-db (2.8.3-2ubuntu0.1) ...\n", + "Processing triggers for libc-bin (2.27-3ubuntu1.5) ...\n", + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Requirement already satisfied: pip in /usr/local/lib/python3.7/dist-packages (21.1.3)\n", + "Collecting pip\n", + " Downloading pip-22.2.2-py3-none-any.whl (2.0 MB)\n", + "\u001b[K |████████████████████████████████| 2.0 MB 4.2 MB/s \n", + "\u001b[?25hInstalling collected packages: pip\n", + " Attempting uninstall: pip\n", + " Found existing installation: pip 21.1.3\n", + " Uninstalling pip-21.1.3:\n", + " Successfully uninstalled pip-21.1.3\n", + "Successfully installed pip-22.2.2\n", + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Collecting rasterio\n", + " Downloading rasterio-1.2.10-cp37-cp37m-manylinux1_x86_64.whl (19.3 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m19.3/19.3 MB\u001b[0m \u001b[31m44.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: cligj>=0.5 in /usr/local/lib/python3.7/dist-packages (from rasterio) (0.7.2)\n", + "Collecting affine\n", + " Downloading affine-2.3.1-py2.py3-none-any.whl (16 kB)\n", + "Collecting snuggs>=1.4.1\n", + " Downloading snuggs-1.4.7-py3-none-any.whl (5.4 kB)\n", + "Requirement already satisfied: certifi in /usr/local/lib/python3.7/dist-packages (from rasterio) (2022.6.15)\n", + "Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from rasterio) (57.4.0)\n", + "Requirement already satisfied: click>=4.0 in /usr/local/lib/python3.7/dist-packages (from rasterio) (7.1.2)\n", + "Requirement already satisfied: click-plugins in /usr/local/lib/python3.7/dist-packages (from rasterio) (1.1.1)\n", + "Requirement already satisfied: attrs in /usr/local/lib/python3.7/dist-packages (from rasterio) (22.1.0)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from rasterio) (1.21.6)\n", + "Requirement already satisfied: pyparsing>=2.1.6 in /usr/local/lib/python3.7/dist-packages (from snuggs>=1.4.1->rasterio) (3.0.9)\n", + "Installing collected packages: affine, snuggs, rasterio\n", + "Successfully installed affine-2.3.1 rasterio-1.2.10 snuggs-1.4.7\n", + "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[0m" + ] + } + ] }, { "cell_type": "code", @@ -121,10 +512,50 @@ "import tensorflow as tf" ], "metadata": { - "id": "KgpZR6Y9Ypvb" + "id": "KgpZR6Y9Ypvb", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "259067d3-a8b7-4300-cf49-4310a93327a8" }, - "execution_count": null, - "outputs": [] + "execution_count": 25, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Requirement already satisfied: geopandas in /usr/local/lib/python3.7/dist-packages (0.10.2)\n", + "Requirement already satisfied: fiona>=1.8 in /usr/local/lib/python3.7/dist-packages (from geopandas) (1.8.21)\n", + "Requirement already satisfied: pyproj>=2.2.0 in /usr/local/lib/python3.7/dist-packages (from geopandas) (3.2.1)\n", + "Requirement already satisfied: shapely>=1.6 in /usr/local/lib/python3.7/dist-packages (from geopandas) (1.8.4)\n", + "Requirement already satisfied: pandas>=0.25.0 in /usr/local/lib/python3.7/dist-packages (from geopandas) (1.3.5)\n", + "Requirement already satisfied: click>=4.0 in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas) (7.1.2)\n", + "Requirement already satisfied: cligj>=0.5 in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas) (0.7.2)\n", + "Requirement already satisfied: certifi in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas) (2022.6.15)\n", + "Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas) (57.4.0)\n", + "Requirement already satisfied: attrs>=17 in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas) (22.1.0)\n", + "Requirement already satisfied: click-plugins>=1.0 in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas) (1.1.1)\n", + "Requirement already satisfied: munch in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas) (2.5.0)\n", + "Requirement already satisfied: six>=1.7 in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas) (1.15.0)\n", + "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas>=0.25.0->geopandas) (2022.2.1)\n", + "Requirement already satisfied: numpy>=1.17.3 in /usr/local/lib/python3.7/dist-packages (from pandas>=0.25.0->geopandas) (1.21.6)\n", + "Requirement already satisfied: python-dateutil>=2.7.3 in /usr/local/lib/python3.7/dist-packages (from pandas>=0.25.0->geopandas) (2.8.2)\n", + "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[0mLooking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Collecting PyShp\n", + " Downloading pyshp-2.3.1-py2.py3-none-any.whl (46 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m46.5/46.5 kB\u001b[0m \u001b[31m4.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hInstalling collected packages: PyShp\n", + "Successfully installed PyShp-2.3.1\n", + "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[0mLooking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Requirement already satisfied: gdal in /usr/local/lib/python3.7/dist-packages (2.2.2)\n", + "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[0m" + ] + } + ] }, { "cell_type": "code", @@ -136,7 +567,7 @@ "metadata": { "id": "8VNcBhx8YsmN" }, - "execution_count": null, + "execution_count": 26, "outputs": [] }, { @@ -150,7 +581,7 @@ "}\n", "\n", "map = folium.Map(location=[1.64, 110.20],zoom_start=4, height=1000,width=1500)\n", - "mapid = dataset.get(100).getMapId(visualization)\n", + "mapid = dataset.getMapId(visualization)\n", "folium.TileLayer(\n", " tiles=mapid['tile_fetcher'].url_format,\n", " attr='Map Data © Google Earth Engine',\n", @@ -167,10 +598,115 @@ "map" ], "metadata": { - "id": "pq884v0BYwch" + "id": "pq884v0BYwch", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 719 + }, + "outputId": "77c3ac2d-7f19-4cbf-d021-6bcadef87c3b" }, - "execution_count": null, - "outputs": [] + "execution_count": 29, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "
Make this Notebook Trusted to load map: File -> Trust Notebook
" + ] + }, + "metadata": {}, + "execution_count": 29 + } + ] }, { "cell_type": "code", @@ -184,7 +720,7 @@ "metadata": { "id": "OQCimRqSYy7i" }, - "execution_count": null, + "execution_count": 30, "outputs": [] }, { @@ -199,7 +735,7 @@ "metadata": { "id": "mvep2QIYY4Dj" }, - "execution_count": null, + "execution_count": 31, "outputs": [] }, { @@ -243,6 +779,574 @@ }, "execution_count": null, "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "u_lon = 116.2621\n", + "u_lat = 39.8412\n", + "u_poi = ee.Geometry.Point(u_lon, u_lat)\n", + "# Create a buffer zone of 10 km around Lyon.\n", + "lyon = u_poi.buffer(100000) # meters\n", + "\n", + "collectionList = dataset.toList(dataset.size())\n", + "collectionSize = dataset.size().getInfo()\n", + "for i in range(collectionSize):\n", + " ee.batch.Export.image.toDrive(image = ee.Image(collectionList.get(i)).clip(lyon), fileNamePrefix = 'gedi' + str(i + 1), crs='EPSG:4326', fileFormat='GeoTIFF').start()\n", + " os.system('mv drive/MyDrive/gedi.tif drive/MyDrive/ndui/gedi'+str(i+1)+'.tif')\n", + " print(i)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "alwRaoygZCDy", + "outputId": "a3a50919-9ee6-459b-99d2-b4b37a9792b9" + }, + "execution_count": 42, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n", + "10\n", + "11\n", + "12\n", + "13\n", + "14\n", + "15\n", + "16\n", + "17\n", + "18\n", + "19\n", + "20\n", + "21\n", + "22\n", + "23\n", + "24\n", + "25\n", + "26\n", + "27\n", + "28\n", + "29\n", + "30\n", + "31\n", + "32\n", + "33\n", + "34\n", + "35\n", + "36\n", + "37\n", + "38\n", + "39\n", + "40\n", + "41\n", + "42\n", + "43\n", + "44\n", + "45\n", + "46\n", + "47\n", + "48\n", + "49\n", + "50\n", + "51\n", + "52\n", + "53\n", + "54\n", + "55\n", + "56\n", + "57\n", + "58\n", + "59\n", + "60\n", + "61\n", + "62\n", + "63\n", + "64\n", + "65\n", + "66\n", + "67\n", + "68\n", + "69\n", + "70\n", + "71\n", + "72\n", + "73\n", + "74\n", + "75\n", + "76\n", + "77\n", + "78\n", + "79\n", + "80\n", + "81\n", + "82\n", + "83\n", + "84\n", + "85\n", + "86\n", + "87\n", + "88\n", + "89\n", + "90\n", + "91\n", + "92\n", + "93\n", + "94\n", + "95\n", + "96\n", + "97\n", + "98\n", + "99\n", + "100\n", + "101\n", + "102\n", + "103\n", + "104\n", + "105\n", + "106\n", + "107\n", + "108\n", + "109\n", + "110\n", + "111\n", + "112\n", + "113\n", + "114\n", + "115\n", + "116\n", + "117\n", + "118\n", + "119\n", + "120\n", + "121\n", + "122\n", + "123\n", + "124\n", + "125\n", + "126\n", + "127\n", + "128\n", + "129\n", + "130\n", + "131\n", + "132\n", + "133\n", + "134\n", + "135\n", + "136\n", + "137\n", + "138\n", + "139\n", + "140\n", + "141\n", + "142\n", + "143\n", + "144\n", + "145\n", + "146\n", + "147\n", + "148\n", + "149\n", + "150\n", + "151\n", + "152\n", + "153\n", + "154\n", + "155\n", + "156\n", + "157\n", + "158\n", + "159\n", + "160\n", + "161\n", + "162\n", + "163\n", + "164\n", + "165\n", + "166\n", + "167\n", + "168\n", + "169\n", + "170\n", + "171\n", + "172\n", + "173\n", + "174\n", + "175\n", + "176\n", + "177\n", + "178\n", + "179\n", + "180\n", + "181\n", + "182\n", + "183\n", + "184\n", + "185\n", + "186\n", + "187\n", + "188\n", + "189\n", + "190\n", + "191\n", + "192\n", + "193\n", + "194\n", + "195\n", + "196\n", + "197\n", + "198\n", + "199\n", + "200\n", + "201\n", + "202\n", + "203\n", + "204\n", + "205\n", + "206\n", + "207\n", + "208\n", + "209\n", + "210\n", + "211\n", + "212\n", + "213\n", + "214\n", + "215\n", + "216\n", + "217\n", + "218\n", + "219\n", + "220\n", + "221\n", + "222\n", + "223\n", + "224\n", + "225\n", + "226\n", + "227\n", + "228\n", + "229\n", + "230\n", + "231\n", + "232\n", + "233\n", + "234\n", + "235\n", + "236\n", + "237\n", + "238\n", + "239\n", + "240\n", + "241\n", + "242\n", + "243\n", + "244\n", + "245\n", + "246\n", + "247\n", + "248\n", + "249\n", + "250\n", + "251\n", + "252\n", + "253\n", + "254\n", + "255\n", + "256\n", + "257\n", + "258\n", + "259\n", + "260\n", + "261\n", + "262\n", + "263\n", + "264\n", + "265\n", + "266\n", + "267\n", + "268\n", + "269\n", + "270\n", + "271\n", + "272\n", + "273\n", + "274\n", + "275\n", + "276\n", + "277\n", + "278\n", + "279\n", + "280\n", + "281\n", + "282\n", + "283\n", + "284\n", + "285\n", + "286\n", + "287\n", + "288\n", + "289\n", + "290\n", + "291\n", + "292\n", + "293\n", + "294\n", + "295\n", + "296\n", + "297\n", + "298\n", + "299\n", + "300\n", + "301\n", + "302\n", + "303\n", + "304\n", + "305\n", + "306\n", + "307\n", + "308\n", + "309\n", + "310\n", + "311\n", + "312\n", + "313\n", + "314\n", + "315\n", + "316\n", + "317\n", + "318\n", + "319\n", + "320\n", + "321\n", + "322\n", + "323\n", + "324\n", + "325\n", + "326\n", + "327\n", + "328\n", + "329\n", + "330\n", + "331\n", + "332\n", + "333\n", + "334\n", + "335\n", + "336\n", + "337\n", + "338\n", + "339\n", + "340\n", + "341\n", + "342\n", + "343\n", + "344\n", + "345\n" + ] + }, + { + "output_type": "error", + "ename": "KeyboardInterrupt", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/urllib3/connectionpool.py\u001b[0m in \u001b[0;36m_make_request\u001b[0;34m(self, conn, method, url, timeout, chunked, **httplib_request_kw)\u001b[0m\n\u001b[1;32m 376\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;31m# Python 2.7, use buffering of HTTP responses\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 377\u001b[0;31m \u001b[0mhttplib_response\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mconn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgetresponse\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbuffering\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 378\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;31m# Python 3\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mTypeError\u001b[0m: getresponse() got an unexpected keyword argument 'buffering'", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0mcollectionSize\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdataset\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgetInfo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcollectionSize\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m \u001b[0mee\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbatch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mExport\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimage\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtoDrive\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimage\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mee\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mImage\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcollectionList\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlyon\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfileNamePrefix\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'gedi'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcrs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'EPSG:4326'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfileFormat\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'GeoTIFF'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstart\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 11\u001b[0m \u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msystem\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'mv drive/MyDrive/gedi.tif drive/MyDrive/ndui/gedi'\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;34m'.tif'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 12\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/ee/batch.py\u001b[0m in \u001b[0;36mstart\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 89\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 90\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtask_type\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mTask\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mEXPORT_IMAGE\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 91\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexportImage\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_request_id\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 92\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtask_type\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mTask\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mType\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mEXPORT_MAP\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 93\u001b[0m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexportMap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_request_id\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/ee/data.py\u001b[0m in \u001b[0;36mexportImage\u001b[0;34m(request_id, params)\u001b[0m\n\u001b[1;32m 1300\u001b[0m return _prepare_and_run_export(\n\u001b[1;32m 1301\u001b[0m \u001b[0mrequest_id\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mparams\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1302\u001b[0;31m _get_cloud_api_resource().projects().image().export)\n\u001b[0m\u001b[1;32m 1303\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1304\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/ee/data.py\u001b[0m in \u001b[0;36m_prepare_and_run_export\u001b[0;34m(request_id, params, export_endpoint)\u001b[0m\n\u001b[1;32m 1421\u001b[0m return _execute_cloud_call(\n\u001b[1;32m 1422\u001b[0m \u001b[0mexport_endpoint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mproject\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0m_get_projects_path\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbody\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1423\u001b[0;31m num_retries=num_retries)\n\u001b[0m\u001b[1;32m 1424\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1425\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/ee/data.py\u001b[0m in \u001b[0;36m_execute_cloud_call\u001b[0;34m(call, num_retries)\u001b[0m\n\u001b[1;32m 326\u001b[0m \"\"\"\n\u001b[1;32m 327\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 328\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mcall\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexecute\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnum_retries\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnum_retries\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 329\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mgoogleapiclient\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0merrors\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mHttpError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 330\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0m_translate_cloud_exception\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/googleapiclient/_helpers.py\u001b[0m in \u001b[0;36mpositional_wrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 132\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mpositional_parameters_enforcement\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mPOSITIONAL_WARNING\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 133\u001b[0m \u001b[0mlogger\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwarning\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmessage\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 134\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mwrapped\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 135\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 136\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mpositional_wrapper\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/googleapiclient/http.py\u001b[0m in \u001b[0;36mexecute\u001b[0;34m(self, http, num_retries)\u001b[0m\n\u001b[1;32m 907\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmethod\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 908\u001b[0m \u001b[0mbody\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbody\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 909\u001b[0;31m \u001b[0mheaders\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mheaders\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 910\u001b[0m )\n\u001b[1;32m 911\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/googleapiclient/http.py\u001b[0m in \u001b[0;36m_retry_request\u001b[0;34m(http, num_retries, req_type, sleep, rand, uri, method, *args, **kwargs)\u001b[0m\n\u001b[1;32m 175\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 176\u001b[0m \u001b[0mexception\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 177\u001b[0;31m \u001b[0mresp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcontent\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mhttp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrequest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0muri\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 178\u001b[0m \u001b[0;31m# Retry on SSL errors and socket timeout errors.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 179\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0m_ssl_SSLError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mssl_error\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/google_auth_httplib2.py\u001b[0m in \u001b[0;36mrequest\u001b[0;34m(self, uri, method, body, headers, **kwargs)\u001b[0m\n\u001b[1;32m 199\u001b[0m \u001b[0;31m# Make the request.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 200\u001b[0m response, content = self.http.request(\n\u001b[0;32m--> 201\u001b[0;31m uri, method, body=body, headers=request_headers, **kwargs)\n\u001b[0m\u001b[1;32m 202\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 203\u001b[0m \u001b[0;31m# If the response indicated that the credentials needed to be\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/httplib2/__init__.py\u001b[0m in \u001b[0;36mrequest\u001b[0;34m(self, uri, method, body, headers, redirections, connection_type)\u001b[0m\n\u001b[1;32m 1989\u001b[0m \u001b[0mheaders\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1990\u001b[0m \u001b[0mredirections\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1991\u001b[0;31m \u001b[0mcachekey\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1992\u001b[0m )\n\u001b[1;32m 1993\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/httplib2/__init__.py\u001b[0m in \u001b[0;36m_request\u001b[0;34m(self, conn, host, absolute_uri, request_uri, method, body, headers, redirections, cachekey)\u001b[0m\n\u001b[1;32m 1649\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1650\u001b[0m (response, content) = self._conn_request(\n\u001b[0;32m-> 1651\u001b[0;31m \u001b[0mconn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrequest_uri\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbody\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mheaders\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1652\u001b[0m )\n\u001b[1;32m 1653\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/httplib2shim/__init__.py\u001b[0m in \u001b[0;36m_conn_request\u001b[0;34m(self, conn, request_uri, method, body, headers)\u001b[0m\n\u001b[1;32m 146\u001b[0m \u001b[0mretries\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0murllib3\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mRetry\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtotal\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mredirect\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 147\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0murllib3\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTimeout\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtotal\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtimeout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 148\u001b[0;31m decode_content=decode)\n\u001b[0m\u001b[1;32m 149\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 150\u001b[0m \u001b[0mresponse\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_map_response\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0murllib3_response\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdecode\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdecode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/urllib3/request.py\u001b[0m in \u001b[0;36mrequest\u001b[0;34m(self, method, url, fields, headers, **urlopen_kw)\u001b[0m\n\u001b[1;32m 70\u001b[0m return self.request_encode_body(method, url, fields=fields,\n\u001b[1;32m 71\u001b[0m \u001b[0mheaders\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mheaders\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 72\u001b[0;31m **urlopen_kw)\n\u001b[0m\u001b[1;32m 73\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 74\u001b[0m def request_encode_url(self, method, url, fields=None, headers=None,\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/urllib3/request.py\u001b[0m in \u001b[0;36mrequest_encode_body\u001b[0;34m(self, method, url, fields, headers, encode_multipart, multipart_boundary, **urlopen_kw)\u001b[0m\n\u001b[1;32m 148\u001b[0m \u001b[0mextra_kw\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mupdate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0murlopen_kw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 149\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 150\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0murlopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0murl\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mextra_kw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/urllib3/poolmanager.py\u001b[0m in \u001b[0;36murlopen\u001b[0;34m(self, method, url, redirect, **kw)\u001b[0m\n\u001b[1;32m 322\u001b[0m \u001b[0mresponse\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mconn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0murlopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0murl\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 323\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 324\u001b[0;31m \u001b[0mresponse\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mconn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0murlopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mu\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrequest_uri\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 325\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 326\u001b[0m \u001b[0mredirect_location\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mredirect\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mresponse\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_redirect_location\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/urllib3/connectionpool.py\u001b[0m in \u001b[0;36murlopen\u001b[0;34m(self, method, url, body, headers, retries, redirect, assert_same_host, timeout, pool_timeout, release_conn, chunked, body_pos, **response_kw)\u001b[0m\n\u001b[1;32m 598\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtimeout_obj\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 599\u001b[0m \u001b[0mbody\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mbody\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mheaders\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mheaders\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 600\u001b[0;31m chunked=chunked)\n\u001b[0m\u001b[1;32m 601\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 602\u001b[0m \u001b[0;31m# If we're going to release the connection in ``finally:``, then\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/urllib3/connectionpool.py\u001b[0m in \u001b[0;36m_make_request\u001b[0;34m(self, conn, method, url, timeout, chunked, **httplib_request_kw)\u001b[0m\n\u001b[1;32m 378\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;31m# Python 3\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 379\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 380\u001b[0;31m \u001b[0mhttplib_response\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mconn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgetresponse\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 381\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 382\u001b[0m \u001b[0;31m# Remove the TypeError from the exception chain in Python 3;\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/lib/python3.7/http/client.py\u001b[0m in \u001b[0;36mgetresponse\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1371\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1372\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1373\u001b[0;31m \u001b[0mresponse\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbegin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1374\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mConnectionError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1375\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/lib/python3.7/http/client.py\u001b[0m in \u001b[0;36mbegin\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 317\u001b[0m \u001b[0;31m# read until we get a non-100 response\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 318\u001b[0m \u001b[0;32mwhile\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 319\u001b[0;31m \u001b[0mversion\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstatus\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreason\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_read_status\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 320\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mstatus\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0mCONTINUE\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 321\u001b[0m \u001b[0;32mbreak\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/lib/python3.7/http/client.py\u001b[0m in \u001b[0;36m_read_status\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 278\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 279\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_read_status\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 280\u001b[0;31m \u001b[0mline\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreadline\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_MAXLINE\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"iso-8859-1\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 281\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mline\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0m_MAXLINE\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 282\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mLineTooLong\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"status line\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/lib/python3.7/socket.py\u001b[0m in \u001b[0;36mreadinto\u001b[0;34m(self, b)\u001b[0m\n\u001b[1;32m 587\u001b[0m \u001b[0;32mwhile\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 588\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 589\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_sock\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrecv_into\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 590\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mtimeout\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 591\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_timeout_occurred\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/lib/python3.7/ssl.py\u001b[0m in \u001b[0;36mrecv_into\u001b[0;34m(self, buffer, nbytes, flags)\u001b[0m\n\u001b[1;32m 1069\u001b[0m \u001b[0;34m\"non-zero flags not allowed in calls to recv_into() on %s\"\u001b[0m \u001b[0;34m%\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1070\u001b[0m self.__class__)\n\u001b[0;32m-> 1071\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnbytes\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbuffer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1072\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1073\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrecv_into\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbuffer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnbytes\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mflags\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/lib/python3.7/ssl.py\u001b[0m in \u001b[0;36mread\u001b[0;34m(self, len, buffer)\u001b[0m\n\u001b[1;32m 927\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 928\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mbuffer\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 929\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_sslobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbuffer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 930\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 931\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_sslobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "!pip install geopandas" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Os36QBw6Tx2-", + "outputId": "b97a9a84-94e9-466d-b033-61b8e4955f9a" + }, + "execution_count": 3, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Collecting geopandas\n", + " Downloading geopandas-0.10.2-py2.py3-none-any.whl (1.0 MB)\n", + "\u001b[K |████████████████████████████████| 1.0 MB 4.2 MB/s \n", + "\u001b[?25hRequirement already satisfied: pandas>=0.25.0 in /usr/local/lib/python3.7/dist-packages (from geopandas) (1.3.5)\n", + "Requirement already satisfied: shapely>=1.6 in /usr/local/lib/python3.7/dist-packages (from geopandas) (1.8.4)\n", + "Collecting fiona>=1.8\n", + " Downloading Fiona-1.8.21-cp37-cp37m-manylinux2014_x86_64.whl (16.7 MB)\n", + "\u001b[K |████████████████████████████████| 16.7 MB 283 kB/s \n", + "\u001b[?25hCollecting pyproj>=2.2.0\n", + " Downloading pyproj-3.2.1-cp37-cp37m-manylinux2010_x86_64.whl (6.3 MB)\n", + "\u001b[K |████████████████████████████████| 6.3 MB 25.4 MB/s \n", + "\u001b[?25hRequirement already satisfied: six>=1.7 in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas) (1.15.0)\n", + "Collecting click-plugins>=1.0\n", + " Downloading click_plugins-1.1.1-py2.py3-none-any.whl (7.5 kB)\n", + "Collecting munch\n", + " Downloading munch-2.5.0-py2.py3-none-any.whl (10 kB)\n", + "Requirement already satisfied: click>=4.0 in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas) (7.1.2)\n", + "Collecting cligj>=0.5\n", + " Downloading cligj-0.7.2-py3-none-any.whl (7.1 kB)\n", + "Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas) (57.4.0)\n", + "Requirement already satisfied: attrs>=17 in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas) (22.1.0)\n", + "Requirement already satisfied: certifi in /usr/local/lib/python3.7/dist-packages (from fiona>=1.8->geopandas) (2022.6.15)\n", + "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas>=0.25.0->geopandas) (2022.2.1)\n", + "Requirement already satisfied: python-dateutil>=2.7.3 in /usr/local/lib/python3.7/dist-packages (from pandas>=0.25.0->geopandas) (2.8.2)\n", + "Requirement already satisfied: numpy>=1.17.3 in /usr/local/lib/python3.7/dist-packages (from pandas>=0.25.0->geopandas) (1.21.6)\n", + "Installing collected packages: munch, cligj, click-plugins, pyproj, fiona, geopandas\n", + "Successfully installed click-plugins-1.1.1 cligj-0.7.2 fiona-1.8.21 geopandas-0.10.2 munch-2.5.0 pyproj-3.2.1\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import geopandas" + ], + "metadata": { + "id": "-JNsTllsReCO" + }, + "execution_count": 4, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "df = geopandas.read_file(\"drive/MyDrive/ndui/referenceData.shp\") " + ], + "metadata": { + "id": "dpZurhHkTpee" + }, + "execution_count": 9, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "df.plot()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 283 + }, + "id": "AC26KeSnUGCv", + "outputId": "6e7bb1d3-7c18-403f-d45f-4008ba6a36c2" + }, + "execution_count": 15, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 15 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "df.head()['geometry']" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "4DvjIs3AUSgz", + "outputId": "38789c26-9086-41a0-a839-a5783a6b5411" + }, + "execution_count": 20, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "0 POLYGON ((10.75297 0.76165, 10.75319 0.76165, ...\n", + "1 POLYGON ((10.75292 0.64206, 10.75315 0.64206, ...\n", + "2 POLYGON ((10.75289 0.53060, 10.75311 0.53060, ...\n", + "3 POLYGON ((10.75287 0.43814, 10.75309 0.43814, ...\n", + "4 POLYGON ((10.75286 0.43248, 10.75309 0.43248, ...\n", + "Name: geometry, dtype: geometry" + ] + }, + "metadata": {}, + "execution_count": 20 + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "KNh86ejwVZn9" + }, + "execution_count": null, + "outputs": [] } ] } \ No newline at end of file From cbaac630a4170a9bcaf94a185e7ea7abff132de9 Mon Sep 17 00:00:00 2001 From: Manmeet Singh Date: Sat, 10 Sep 2022 23:42:37 -0500 Subject: [PATCH 12/14] Create csi_ets.py --- xarray_tutorial/csi_ets.py | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 xarray_tutorial/csi_ets.py diff --git a/xarray_tutorial/csi_ets.py b/xarray_tutorial/csi_ets.py new file mode 100644 index 0000000..600bb50 --- /dev/null +++ b/xarray_tutorial/csi_ets.py @@ -0,0 +1,22 @@ +arr1 = ds_tp_era5_[0].copy() +arr2 = ds_dl_[0].copy() +thres = 0.5 +def csi_ets(arr1, arr2, thres): + + arr1_ = arr1>thres + arr2_ = arr2>thres + joint_bool = (arr1>thres)*(arr2>thres) + hits = np.sum(joint_bool) + arr3_ = arr1_ + arr3_[(arr1_==True) & (arr2_==True)] = False + misses = np.sum(arr3_*arr1_) + arr4_ = arr2_ + arr4_[(arr1_==True) & (arr2_==True)] = False + false_alarms = np.sum(arr4_*arr2_) + + csi = hits / (hits+misses+false_alarms) + e = arr1.shape[0] + ets = (hits - e)/(hits+misses+false_alarms-e) + + return csi, ets +csi, ets = csi_ets(arr1, arr2, thres) From 2720ff49bcf9bfbb74f7394723e990bc34fc0092 Mon Sep 17 00:00:00 2001 From: Manmeet Singh Date: Sun, 11 Sep 2022 01:31:20 -0500 Subject: [PATCH 13/14] Create common_time.py --- xarray_tutorial/common_time.py | 6 ++++++ 1 file changed, 6 insertions(+) create mode 100644 xarray_tutorial/common_time.py diff --git a/xarray_tutorial/common_time.py b/xarray_tutorial/common_time.py new file mode 100644 index 0000000..b78add8 --- /dev/null +++ b/xarray_tutorial/common_time.py @@ -0,0 +1,6 @@ +for arr in [gfs_f24_e,ds_tp_era5, ds_dl, ds_lr]: + arr['time'] = arr.indexes['time'].normalize() + +ds_tp_era5_e = ds_tp_era5.sel(time=ds_tp_era5.time.isin(gfs_f24_e.time.values)) +ds_dl_e = ds_dl.sel(time=ds_dl.time.isin(gfs_f24_e.time.values)) +ds_lr_e = ds_lr.sel(time=ds_lr.time.isin(gfs_f24_e.time.values)) From c255425607139a3aa50057c1295522cdf6069f69 Mon Sep 17 00:00:00 2001 From: Manmeet Singh Date: Tue, 17 Dec 2024 11:01:25 -0600 Subject: [PATCH 14/14] Add files via upload --- xarray_tutorial/power_spectrum_density.ipynb | 753 +++++++++++++++++++ 1 file changed, 753 insertions(+) create mode 100644 xarray_tutorial/power_spectrum_density.ipynb diff --git a/xarray_tutorial/power_spectrum_density.ipynb b/xarray_tutorial/power_spectrum_density.ipynb new file mode 100644 index 0000000..49e5f75 --- /dev/null +++ b/xarray_tutorial/power_spectrum_density.ipynb @@ -0,0 +1,753 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "eDHXcRW9YYYX" + }, + "outputs": [], + "source": [ + "import dataclasses\n", + "import typing as t\n", + "\n", + "import numpy as np\n", + "import xarray as xr\n", + "\n", + "# Approximate Earth radius in meters (needed for circumference calculation)\n", + "EARTH_RADIUS_M = 6371000.0\n", + "\n", + "@dataclasses.dataclass\n", + "class DerivedVariable:\n", + " \"\"\"Derived variable base class.\"\"\"\n", + " @property\n", + " def base_variables(self) -> list[str]:\n", + " return []\n", + "\n", + " @property\n", + " def core_dims(self) -> t.Tuple[t.Tuple[t.List[str], ...], t.List[str]]:\n", + " raise NotImplementedError\n", + "\n", + " def compute(self, dataset: xr.Dataset) -> xr.DataArray:\n", + " raise NotImplementedError\n", + "\n", + "@dataclasses.dataclass\n", + "class ZonalEnergySpectrum(DerivedVariable):\n", + " \"\"\"Compute energy spectrum along the zonal direction for a given variable.\"\"\"\n", + " variable_name: str\n", + "\n", + " @property\n", + " def base_variables(self) -> list[str]:\n", + " return [self.variable_name]\n", + "\n", + " @property\n", + " def core_dims(self) -> t.Tuple[t.Tuple[t.List[str], ...], t.List[str]]:\n", + " return (['longitude'],), ['zonal_wavenumber']\n", + "\n", + " def _circumference(self, dataset: xr.Dataset) -> xr.DataArray:\n", + " \"\"\"Earth's circumference as a function of latitude.\"\"\"\n", + " circum_at_equator = 2 * np.pi * EARTH_RADIUS_M\n", + " return np.cos(dataset.latitude * np.pi / 180) * circum_at_equator\n", + "\n", + " def lon_spacing_m(self, dataset: xr.Dataset) -> xr.DataArray:\n", + " \"\"\"Spacing (meters) between longitudinal values in `dataset`.\"\"\"\n", + " diffs = dataset.longitude.diff('longitude')\n", + " if np.max(np.abs(diffs - diffs[0])) > 1e-3:\n", + " raise ValueError(\n", + " f'Expected uniform longitude spacing. {dataset.longitude.values=}'\n", + " )\n", + " return self._circumference(dataset) * diffs[0].data / 360\n", + "\n", + " def compute(self, dataset: xr.Dataset) -> xr.DataArray:\n", + " \"\"\"Computes zonal power at wavenumber and frequency.\"\"\"\n", + " spacing = self.lon_spacing_m(dataset)\n", + "\n", + " def simple_power(f_x):\n", + " f_k = np.fft.rfft(f_x, axis=-1, norm='forward')\n", + " # freq > 0 should be counted twice in power since it accounts for both\n", + " # positive and negative frequency components\n", + " one_and_many_twos = np.concatenate(([1], [2] * (f_k.shape[-1] - 1)))\n", + " return np.real(f_k * np.conj(f_k)) * one_and_many_twos\n", + "\n", + " # Apply the FFT-based power calculation along 'longitude'\n", + " spectrum = xr.apply_ufunc(\n", + " simple_power,\n", + " dataset[self.variable_name],\n", + " input_core_dims=[['longitude']],\n", + " output_core_dims=[['zonal_wavenumber']],\n", + " exclude_dims={'longitude'},\n", + " )\n", + "\n", + " # Assign coordinates\n", + " spectrum = spectrum.assign_coords(\n", + " zonal_wavenumber=('zonal_wavenumber', spectrum.zonal_wavenumber.data)\n", + " )\n", + " base_frequency = xr.DataArray(\n", + " np.fft.rfftfreq(dataset.sizes['longitude']),\n", + " dims='zonal_wavenumber',\n", + " coords={'zonal_wavenumber': spectrum.zonal_wavenumber}\n", + " )\n", + " spectrum = spectrum.assign_coords(frequency=base_frequency / spacing)\n", + " spectrum['frequency'] = spectrum.frequency.assign_attrs(units='1 / m')\n", + "\n", + " spectrum = spectrum.assign_coords(wavelength=1 / spectrum.frequency)\n", + " spectrum['wavelength'] = spectrum.wavelength.assign_attrs(units='m')\n", + "\n", + " # Scale by circumference so that the sum of spectra equals spatial integral of |f|²\n", + " return spectrum * self._circumference(spectrum)" + ] + }, + { + "cell_type": "code", + "source": [ + "time = np.arange(np.datetime64('2020-01-01'), np.datetime64('2020-01-11'))\n", + "latitude = np.linspace(-90, 90, 32)\n", + "longitude = np.linspace(0, 360, 64, endpoint=False)\n", + "\n", + "# Synthetic geopotential data (random values)\n", + "data = np.random.rand(len(time), len(latitude), len(longitude)) * 10000.0\n", + "\n", + "ds = xr.Dataset(\n", + " {\n", + " 'geopotential': (['time', 'latitude', 'longitude'], data)\n", + " },\n", + " coords={\n", + " 'time': time,\n", + " 'latitude': latitude,\n", + " 'longitude': longitude\n", + " }\n", + ")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "dCDTBG3Zi-2T", + "outputId": "b484646f-38fe-4fae-8854-068a82bf9499" + }, + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + ":12: UserWarning: Converting non-nanosecond precision datetime values to nanosecond precision. This behavior can eventually be relaxed in xarray, as it is an artifact from pandas which is now beginning to support non-nanosecond precision values. This warning is caused by passing non-nanosecond np.datetime64 or np.timedelta64 values to the DataArray or Variable constructor; it can be silenced by converting the values to nanosecond precision ahead of time.\n", + " ds = xr.Dataset(\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "ds" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 365 + }, + "id": "ZRFrg5qxjLa6", + "outputId": "97a4eafa-6bbd-4d94-d117-abc65bb94a52" + }, + "execution_count": 3, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " Size: 165kB\n", + "Dimensions: (time: 10, latitude: 32, longitude: 64)\n", + "Coordinates:\n", + " * time (time) datetime64[ns] 80B 2020-01-01 2020-01-02 ... 2020-01-10\n", + " * latitude (latitude) float64 256B -90.0 -84.19 -78.39 ... 84.19 90.0\n", + " * longitude (longitude) float64 512B 0.0 5.625 11.25 ... 343.1 348.8 354.4\n", + "Data variables:\n", + " geopotential (time, latitude, longitude) float64 164kB 2.705e+03 ... 4.9..." + ], + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset> Size: 165kB\n",
+              "Dimensions:       (time: 10, latitude: 32, longitude: 64)\n",
+              "Coordinates:\n",
+              "  * time          (time) datetime64[ns] 80B 2020-01-01 2020-01-02 ... 2020-01-10\n",
+              "  * latitude      (latitude) float64 256B -90.0 -84.19 -78.39 ... 84.19 90.0\n",
+              "  * longitude     (longitude) float64 512B 0.0 5.625 11.25 ... 343.1 348.8 354.4\n",
+              "Data variables:\n",
+              "    geopotential  (time, latitude, longitude) float64 164kB 2.705e+03 ... 4.9...
" + ] + }, + "metadata": {}, + "execution_count": 3 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Instantiate the zonal energy spectrum for 'geopotential'\n", + "zonal_es = ZonalEnergySpectrum('geopotential')\n", + "\n", + "# Compute the spectrum at a given time slice to demonstrate\n", + "# (you can also compute over all times if desired)\n", + "# Here we pick the first time-step just as an example\n", + "spectrum = zonal_es.compute(ds.isel(time=0))\n", + "\n", + "print(\"Zonal Energy Spectrum for 'geopotential' at first time step:\")\n", + "print(spectrum)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "TzjvQSlVjLy1", + "outputId": "f3ebb854-a87d-4682-c238-c8f55770c911" + }, + "execution_count": 4, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Zonal Energy Spectrum for 'geopotential' at first time step:\n", + " Size: 8kB\n", + "array([[6.32623556e-02, 8.40308650e-04, 2.09414829e-03, ...,\n", + " 1.81809897e-03, 1.40751368e-04, 3.90729453e-05],\n", + " [1.05161758e+14, 2.50180676e+12, 1.27712353e+12, ...,\n", + " 1.59507659e+11, 2.32249906e+12, 7.65867106e+11],\n", + " [1.64085187e+14, 1.61106569e+12, 1.04800593e+12, ...,\n", + " 2.44032273e+12, 8.99959896e+11, 3.16317407e+12],\n", + " ...,\n", + " [2.49936572e+14, 1.01596468e+13, 1.79760659e+12, ...,\n", + " 6.77927752e+11, 5.64389663e+11, 5.23039662e+11],\n", + " [9.93131648e+13, 2.67039165e+12, 5.66498283e+12, ...,\n", + " 1.20700013e+12, 3.42791852e+11, 1.04122711e+11],\n", + " [6.73939510e-02, 2.62863363e-03, 6.38759597e-04, ...,\n", + " 1.67957249e-03, 1.59472634e-03, 2.32187659e-05]])\n", + "Coordinates:\n", + " time datetime64[ns] 8B 2020-01-01\n", + " * latitude (latitude) float64 256B -90.0 -84.19 -78.39 ... 84.19 90.0\n", + " * zonal_wavenumber (zonal_wavenumber) int64 264B 0 1 2 3 4 ... 28 29 30 31 32\n", + " frequency (zonal_wavenumber, latitude) float64 8kB 0.0 ... 1.306e+10\n", + " wavelength (zonal_wavenumber, latitude) float64 8kB inf ... 7.66e-11\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import matplotlib.pyplot as plt\n", + "spectrum_wavelength = spectrum.mean(dim='latitude').swap_dims({'zonal_wavenumber': 'wavelength'})\n", + "\n", + "plt.figure(figsize=(8, 4))\n", + "spectrum_wavelength.plot()\n", + "plt.title('Zonal Energy Spectrum (Wavelength on X-axis)')\n", + "plt.xlabel('Wavelength [m]')\n", + "plt.ylabel('Energy Spectrum')\n", + "plt.tight_layout()\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 407 + }, + "id": "ScCH4187jNYc", + "outputId": "67d4eae5-3a61-4e0d-9404-f1845c9af661" + }, + "execution_count": 7, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "yDj94tC1jisQ" + }, + "execution_count": 8, + "outputs": [] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "yPfBA5Fej1bp" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file