Minggu 7_ Google Earth Engine di Colab.ipynb

{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"name":"Minggu 13: Google Earth Engine di Colab.ipynb","provenance":[],"collapsed_sections":[],"toc_visible":true,"mount_file_id":"1xSbcmjaBjiXu1tutA-O0zxd4ySZbEVeY","authorship_tag":"ABX9TyO2TYwxiDg4lc2nqlAisRDE"},"kernelspec":{"name":"python3","display_name":"Python 3"},"widgets":{"application/vnd.jupyter.widget-state+json":{"4361abed10bd46fabf9187a3924d4124":{"model_module":"@jupyter-widgets/output","model_name":"OutputModel","state":{"_view_name":"OutputView","msg_id":"","_dom_classes":[],"_model_name":"OutputModel","outputs":[{"output_type":"display_data","metadata":{"tags":[]},"text/html":"\n        <iframe\n            width=\"800\"\n            height=\"450\"\n            src=\"https://www.youtube.com/embed/h0pz3S6Tvx0\"\n            frameborder=\"0\"\n            allowfullscreen\n        ></iframe>\n        ","text/plain":"<IPython.lib.display.YouTubeVideo at 0x7f2d34fb7ba8>","image/jpeg":"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\n"}],"_view_module":"@jupyter-widgets/output","_model_module_version":"1.0.0","_view_count":null,"_view_module_version":"1.0.0","layout":"IPY_MODEL_b8f7b18a4d4e41e597d1b946ad80f528","_model_module":"@jupyter-widgets/output"}},"b8f7b18a4d4e41e597d1b946ad80f528":{"model_module":"@jupyter-widgets/base","model_name":"LayoutModel","state":{"_view_name":"LayoutView","grid_template_rows":null,"right":null,"justify_content":null,"_view_module":"@jupyter-widgets/base","overflow":null,"_model_module_version":"1.2.0","_view_count":null,"flex_flow":null,"width":"815px","min_width":null,"border":null,"align_items":null,"bottom":null,"_model_module":"@jupyter-widgets/base","top":null,"grid_column":null,"overflow_y":null,"overflow_x":null,"grid_auto_flow":null,"grid_area":null,"grid_template_columns":null,"flex":null,"_model_name":"LayoutModel","justify_items":null,"grid_row":null,"max_height":null,"align_content":null,"visibility":null,"align_self":null,"height":null,"min_height":null,"padding":null,"grid_auto_rows":null,"grid_gap":null,"max_width":null,"order":null,"_view_module_version":"1.2.0","grid_template_areas":null,"object_position":null,"object_fit":null,"grid_auto_columns":null,"margin":null,"display":null,"left":null}}}}},"cells":[{"cell_type":"markdown","metadata":{"id":"gZs3ZpmA1SSv","colab_type":"text"},"source":["\n","<center>\n","<h4> \n","  Pengolahan Citra Digital Minggu 13:\n","</h4>\n","  <h1>\n","  <strong>\n","    Pengenalan Google Earth Engine\n","    di Google Colab\n","  <strong>\n","  </h1>\n","</center>\n","<br>\n","\n","\n","---\n","\n","\n","Materi Minggu ini:\n","\n","*   Pengenalan Google Earth Engine (GEE)\n","*   Google Earth Engine dengan Google Colab\n","*   Contoh-contoh Kasus\n","*   Menggunakan GEE Map\n","*   Penggunaan GEE di QGIS\n","\n","\n"]},{"cell_type":"markdown","metadata":{"id":"rQjxhujMDGb2","colab_type":"text"},"source":["# Pengenalan Google Earth Engine"]},{"cell_type":"markdown","metadata":{"id":"_ApB8jdnt-33","colab_type":"text"},"source":["## Apa itu Google Earth Engine?"]},{"cell_type":"code","metadata":{"id":"GxF_Ykne1Q9z","colab_type":"code","cellView":"form","outputId":"021665e9-c6da-4bc3-8ff1-bddb4932c50c","executionInfo":{"status":"ok","timestamp":1589328423505,"user_tz":-420,"elapsed":1064,"user":{"displayName":"Dany Puguh Laksono","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gjd8eOzv4V9R3fnhZHMJEN542UAJIK5XPlKWPS5=s64","userId":"10973890960709691040"}},"colab":{"base_uri":"https://localhost:8080/","height":336}},"source":["#@markdown Meet Google Earth Engine\n","from IPython.display import HTML\n","HTML('<center><iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/gKGOeTFHnKY\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe></center>')"],"execution_count":0,"outputs":[{"output_type":"execute_result","data":{"text/html":["<center><iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/gKGOeTFHnKY\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe></center>"],"text/plain":["<IPython.core.display.HTML object>"]},"metadata":{"tags":[]},"execution_count":1}]},{"cell_type":"markdown","metadata":{"id":"BZgjTdc9DmT4","colab_type":"text"},"source":["Google Earth Engine merupakan mesin komputasi dan analisis geospasial yang dibuat oleh Google. Google Earth Engine (GEE) memiliki berbagai fitur yang memungkinkan pengolahan citra satelit maupun analisis spasial dapat dilakukan berbasis cloud. Untuk itu, GEE dapat digunakan untuk melakukan pengolahan citra dalam jumlah besar tanpa perlu mengunduh terlebih dahulu citra satelit tersebut\n"]},{"cell_type":"markdown","metadata":{"id":"eE5w8IPqE9ap","colab_type":"text"},"source":["## Menggunakan Google Earth Engine\n","\n","Google Earth Engine dapat diakses dengan menggunakan dua buah bahasa pengantar (API), yaitu:\n","- Javascript\n","- Python\n","\n"," Untuk menggunakan Earth Engine dengan Javascript API dapat digunakan konsol Google Earth Engine yang dapat diakses melalui Code Editor (https://code.earthengine.google.com/). Tampilan Code Editor adalah sebagai berikut:\n","\n"," ![alt text](https://developers.google.com/earth-engine/images/Code_editor_diagram.png)\n","\n","Adapun Earth Engine dengan menggunakan Python API (https://developers.google.com/earth-engine/python_install) dapt digunakan di semua lingkungan platform yang menggunakan Python, seperti IDE, Jupyter Notebook, Conda, maupun yang kita gunakan sekarang, yaitu **Google Colab**. Notebook ini secara khusus akan membahas mengenai penggunaan Earth Engine di Google Colab, seperti cara memanggil citra dari Katalog, serta melakukan analisis dan visualisasi sederhana. \n","\n","Selanjutnya akan dibahas juga mengenai penggunaan QGIS sebagai antarmuka untuk Google Earth Engine. QGIS sebagai perangkat lunak yang populer untuk pengolahan data spasial memiliki antarmuka dalam bahasa Python, sehingga memungkinkan untuk mengakses API dari Google Earth Engine menggunakan plugin. Pada notebook ini akan dibahas panduan singkat tentang pengaturan dan penggunaan plugin GEE for QGIS.\n","\n"]},{"cell_type":"markdown","metadata":{"id":"O_WWx_TacNRG","colab_type":"text"},"source":["# Google Earth Engine pada Google Colab\n","\n","## Tentang Google Colab\n","Google Colaboratory merupakan proyek riset dari Google yang menyediakan antarmuka dalam bentuk Jupyter Notebook yang dapat digunakan untuk melakukan berbagai keperluan analisis data dengan menggunakan bahasa Python. Google Colab diinstall pada mesin virtual dengan sistem operasi Ubuntu, dan memiliki kemampuan yang cukup memadai untuk melakukan analisis, pengolahan dan pemodelan data, termasuk untuk machine learning. Alternatif lain untuk Google Colab adalah [Kaggle Notebook](https://www.kaggle.com/kernels), [Azure Notebook](https://notebooks.azure.com/) dan [Binder](https://mybinder.org/).\n","\n","Google Colab sudah terinstall dengan beberapa modul Python yang umum digunakan, seperti Numpy dan Matplotlib. Demikian juga, Google Colab sudah memiliki dukungan untuk Earth Engine dan Folium. Dengan demikian Google Colab dapat digunakan sebagai antarmuka untuk mengakses API dari Google Earth Engine dengan menggunakan bahasa Python."]},{"cell_type":"markdown","metadata":{"id":"hJmyc_cwcehO","colab_type":"text"},"source":["### Memanggil GEE melalui Google Colab\n","Pada bagian berikut akan diberikan panduan untuk mulai menggunakan GEE Python API dengan Google Colab. Agar dapat digunakan di Google Colab, pengguna harus terlebih dahulu:\n","- Memiliki akun yang terdaftar di Google Earth Engine\n","- Memberikan izin akses (autentikasi) pada notebook yang dimaksud\n","\n","Untuk itu, pada script di bawah ini diberikan langkah untuk melakukan autentikasi notebook ini dengan akun GEE yang telah terdaftar. ```ee.Authenticate()``` merupakan fungsi dari GEE untuk melakukan autentikasi dengan server GEE. Setelah mendapatkan kode autentikasi, kode tersebut harus diisikan pada kolom yang muncul untuk memberikan izin akses pada notebook ini untuk mengakses API GEE untuk Python.\n"]},{"cell_type":"code","metadata":{"id":"-35LTGMvDkQt","colab_type":"code","outputId":"a7d2056c-45ce-4b58-c72a-29719a3c60d5","executionInfo":{"status":"ok","timestamp":1589331009576,"user_tz":-420,"elapsed":76658,"user":{"displayName":"Dany Puguh Laksono","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gjd8eOzv4V9R3fnhZHMJEN542UAJIK5XPlKWPS5=s64","userId":"10973890960709691040"}},"colab":{"base_uri":"https://localhost:8080/","height":190}},"source":["#@markdown *Autentikasi Pengguna GEE*\n","\n","# Import Library Earth Engine\n","import ee\n","print(ee.__version__)\n","\n","# Melakukan Autentikasi Pengguna. Klik link yang muncul, kemudian copykan \n","# token yang diperoleh ke kolom yang tersedia\n","ee.Authenticate()\n","\n","# Mengaktifkan GEE pada Google Colab\n","ee.Initialize() "],"execution_count":0,"outputs":[{"output_type":"stream","text":["0.1.221\n","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://accounts.google.com/o/oauth2/auth?client_id=517222506229-vsmmajv00ul0bs7p89v5m89qs8eb9359.apps.googleusercontent.com&scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fearthengine+https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fdevstorage.full_control&redirect_uri=urn%3Aietf%3Awg%3Aoauth%3A2.0%3Aoob&response_type=code&code_challenge=3ljH3jZZZDvB8kvvbKEqdeBj9KaqRoOKGp5kLAyeFQ8&code_challenge_method=S256\n","\n","The authorization workflow will generate a code, which you should paste in the box below. \n","Enter verification code: 4/zgF78ZDDjH3LMpvSngteUAIzKo2qFUbGDvHPlPZJi5iF6vfFjnV-M88\n","\n","Successfully saved authorization token.\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"yYdgRUoQrhH0","colab_type":"text"},"source":["## Pengujian GEE pada Colab\n","\n","Script berikut digunakan untuk menguji apakah API GEE sudah berhasil ditambahkan dan siap digunakan di Google Colab. Script ini akan memanggil data SRTM, kemudian melakukan sampling pada DEM tersebut pada titik puncak Merapi, kemudian mencetak hasilnya pada sel di Google Colab."]},{"cell_type":"code","metadata":{"id":"1YE6JrrFrgIL","colab_type":"code","outputId":"ed1e5438-0a23-4b3e-a16e-c3c2b4a81959","executionInfo":{"status":"ok","timestamp":1589328496369,"user_tz":-420,"elapsed":73888,"user":{"displayName":"Dany Puguh Laksono","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gjd8eOzv4V9R3fnhZHMJEN542UAJIK5XPlKWPS5=s64","userId":"10973890960709691040"}},"colab":{"base_uri":"https://localhost:8080/","height":34}},"source":["#@markdown *Mencetak Tinggi Puncak Merapi*\n","\n","# memanggil DEM SRTM\n","dem = ee.Image('USGS/SRTMGL1_003')\n","xy = ee.Geometry.Point([110.4369693, -7.540696])\n","\n","# Melakukan sampling\n","elev = dem.sample(xy, 30).first().get('elevation').getInfo()\n","\n","# Mencetak\n","print('Puncak Merapi (m):', elev, 'mdpl')"],"execution_count":0,"outputs":[{"output_type":"stream","text":["Puncak Merapi (m): 2232 mdpl\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"Ld9xrbMAsMjx","colab_type":"text"},"source":["Apabila script di atas tidak berhasil dijalankan dan menghasilkan error, periksa kembali bagian autentikasi GEE pada Google Colab di atas."]},{"cell_type":"markdown","metadata":{"id":"UKwEu_6DFdRq","colab_type":"text"},"source":["## Memanggil Citra dari Katalog Earth Engine\n","\n","Google Colab memiliki library khusus untuk mengatur keluaran tampilan, yaitu iPython. Meskipun demikian, library ini saat ini memiliki beberapa keterbatasan untuk digunakan menampilkan peta maupun hasil analisis dalam bentuk data spasial yang interaktif.\n","\n","Untuk itu, penggunaan Google Earth Engine di Google Colab dapat ditambahkan dengan modul Python bernama **Folium**. Folium merupakan jembatan antara Python dan LeafletJS, sehingga dapat digunakan untuk menampilkan peta interaktif pada konsol Jupyter Notebook."]},{"cell_type":"markdown","metadata":{"id":"rA6weA5U5vrh","colab_type":"text"},"source":["### Pengaturan dasar Folium\n","\n","Bagian ini dilakukan untuk memanggil library Folium pada Google Colab. Folium sendiri sudah terinstall (prebuilt) pada setiap notebook Google Colab sehingga cukup dipanggil dengan menggunakan ```import folium``` untuk mengakses fungsinya.\n","Apabila digunakan notebook lain seperti Jupyter Notebook, Folium harus terlebih dahulu diinstall dengan menggunakan ```!pip install folium```\n","\n","Pengaturan di bawah juga mengkonfigurasi format dari tiles yang akan digunakan untuk menampilkan peta pada Folium/Leaflet. Karena Leaflet menggunakan Tiles untuk menampilkan peta, GEE menyediakan format tiles ini sehingga layer atau citra yang dipanggil dari GEE akan mengikuti format ini untuk ditampilkan pada Folium."]},{"cell_type":"code","metadata":{"id":"wrS470NlFfVI","colab_type":"code","outputId":"434f8b5e-5460-46db-a720-4f55b13122d4","executionInfo":{"status":"ok","timestamp":1589328496371,"user_tz":-420,"elapsed":73873,"user":{"displayName":"Dany Puguh Laksono","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gjd8eOzv4V9R3fnhZHMJEN542UAJIK5XPlKWPS5=s64","userId":"10973890960709691040"}},"colab":{"base_uri":"https://localhost:8080/","height":34}},"source":["#@markdown *Pengaturan dan pemanggilan fungsi Folium*\n","import folium\n","\n","# Format URL untuk memanggil data dari Google Earth \n","# Engine sebagai tile pada LeafletJS\n","EE_TILES = 'https://earthengine.googleapis.com/map/{mapid}/{{z}}/{{x}}/{{y}}?token={token}'\n","\n","print('Folium version: ' + folium.__version__)"],"execution_count":0,"outputs":[{"output_type":"stream","text":["Folium version: 0.11.0\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"B-XNj9yY53Ev","colab_type":"text"},"source":["### Menampilkan citra GEE dengan Folium\n","\n","Script berikut mendemokan bagaimana menampilkan citra yang dipanggil dari server GEE ke dalam Google Colab. Citra yang dipanggil akan ditampilkan sebagai tilelayer. "]},{"cell_type":"code","metadata":{"id":"pHqYP9HV59_J","colab_type":"code","outputId":"da583d05-096a-4fa4-d8d9-585b207f8f01","executionInfo":{"status":"ok","timestamp":1589328496372,"user_tz":-420,"elapsed":73857,"user":{"displayName":"Dany Puguh Laksono","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gjd8eOzv4V9R3fnhZHMJEN542UAJIK5XPlKWPS5=s64","userId":"10973890960709691040"}},"cellView":"code","colab":{"base_uri":"https://localhost:8080/","height":583}},"source":["#@markdown *Demo menampilkan citra dari GEE*\n","\n","# Memanggil SRTM jogja dari GEE\n","Jogja = ee.Image(\"USGS/SRTMGL1_003\")\\\n","         .clip(ee.Geometry.Rectangle(\t110.0089, -8.2414, 110.8603, -7.4959))\n","\n","# Use folium to visualize the imagery.\n","mapid = Jogja.getMapId({'pallete': ['black', 'white'], 'min': 0, 'max': 3000})\n","\n","map = folium.Map(location=[-7.8226, 110.3851],zoom_start=9)\n","folium.TileLayer(\n","    tiles = mapid[\"tile_fetcher\"].url_format,\n","    attr='Google Earth Engine',\n","    overlay=True,\n","    name='median composite',\n","  ).add_to(map)\n","map.add_child(folium.LayerControl())\n","map"],"execution_count":0,"outputs":[{"output_type":"execute_result","data":{"text/html":["<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><span style=\"color:#565656\">Make this Notebook Trusted to load map: File -> Trust Notebook</span><iframe src=\"about:blank\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" data-html=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 onload=\"this.contentDocument.open();this.contentDocument.write(atob(this.getAttribute('data-html')));this.contentDocument.close();\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"],"text/plain":["<folium.folium.Map at 0x7f2d360956a0>"]},"metadata":{"tags":[]},"execution_count":5}]},{"cell_type":"markdown","metadata":{"id":"Ikl4ErJ5_Gsc","colab_type":"text"},"source":["Beberapa parameter yang dapat dipanggil dengan getMapId adalah sebagai berikut:\n","\n","\n","\n","Parameter | Description | Type\n","--------------|-------------|-------------\n","bands\t| Comma-delimited list of three band names to be mapped to RGB| list\n","min|\tValue(s) to map to 0\tnumber or list of three numbers, one for each |band\n","max|\tValue(s) to map to 255\t|number or list of three numbers, one for each band\n","gain|\tValue(s) by which to multiply each pixel value|\tnumber or list of three numbers, one for each band\n","bias|\tValue(s) to add to each DN\t| number or list of three numbers, one for each band\n","gamma|\tGamma correction factor(s)\t| number or list of three numbers, one for each band\n","palette|\tList of CSS-style color strings (single-band images only)\t|comma-separated list of hex strings\n","opacity|\tThe opacity of the layer (0.0 is fully transparent and 1.0 is fully opaque)\t| number\n","format|\tEither \"jpg\" or \"png\"\t|string"]},{"cell_type":"markdown","metadata":{"id":"QWLMhLoZ5223","colab_type":"text"},"source":["### Membuat fungsi khusus untuk menampilkan citra\n","\n","Jika pada script di atas digunakan fungsi folium.Tilelayer untuk menampilkan citra, maka dapat dibuat sebuah fungsi/subroutine tersendiri yang dapat dipanggil kapanpun dibutuhkan untuk menampilkan layer dari GEE. \n","\n","Script berikut membuat fungsi dengan nama Mapdisplay untuk menampilkan layer dari GEE pada Google Colab dengan Folium."]},{"cell_type":"code","metadata":{"id":"fbCtvUgZ_2Mb","colab_type":"code","cellView":"code","colab":{}},"source":["#@markdown *Mapdisplay: Display GEE objects using folium.*\n","def Mapdisplay(center, dicc, Tiles=\"OpenStreetMap\",zoom_start=10):\n","    '''\n","    :param center: Center of the map (Latitude and Longitude).\n","    :param dicc: Earth Engine Geometries or Tiles dictionary\n","    :param Tiles: Mapbox Bright,Mapbox Control Room,Stamen Terrain,Stamen Toner,stamenwatercolor,cartodbpositron.\n","    :zoom_start: Initial zoom level for the map.\n","    :return: A folium.Map object.\n","    '''\n","    mapViz = folium.Map(location=center,tiles=Tiles, zoom_start=zoom_start)\n","    for k,v in dicc.items():\n","      if ee.image.Image in [type(x) for x in v.values()]:\n","        folium.TileLayer(\n","            tiles = v[\"tile_fetcher\"].url_format,\n","            attr  = 'Google Earth Engine',\n","            overlay =True,\n","            name  = k\n","          ).add_to(mapViz)\n","      else:\n","        folium.GeoJson(\n","        data = v,\n","        name = k\n","          ).add_to(mapViz)\n","    mapViz.add_child(folium.LayerControl())\n","    return mapViz"],"execution_count":0,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"DUlvXO1KATl4","colab_type":"text"},"source":["Selanjutnya, fungsi di atas dapat digunakan untuk menampilkan citra menggunakan Folium. Cukup dengan memanggil fungsi Mapdisplay dengan beberapa parameter yang sudah ditentukan, maka citra yang dipanggil dari GEE akan dapat ditampilkan."]},{"cell_type":"code","metadata":{"id":"lW2uuf06AZZO","colab_type":"code","outputId":"ceb33980-513a-4fd2-9812-aa2e01439cbe","executionInfo":{"status":"ok","timestamp":1589328496792,"user_tz":-420,"elapsed":74250,"user":{"displayName":"Dany Puguh Laksono","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gjd8eOzv4V9R3fnhZHMJEN542UAJIK5XPlKWPS5=s64","userId":"10973890960709691040"}},"colab":{"base_uri":"https://localhost:8080/","height":583}},"source":["# Memanggil citra dari Katalog\n","image = ee.Image('LANDSAT/LC08/C01/T1_TOA/LC08_120065_20180505')\n","mapid = image.getMapId({\n","    'bands': ['B4', 'B3', 'B2'], \n","    'min': 0, \n","    'max': 0.3})\n","\n","# Display the map with folium!\n","center=[-7.8226, 110.3851]\n","Mapdisplay(center, {'Median Composite':mapid},zoom_start=10)"],"execution_count":0,"outputs":[{"output_type":"execute_result","data":{"text/html":["<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><span style=\"color:#565656\">Make this Notebook Trusted to load map: File -> Trust Notebook</span><iframe src=\"about:blank\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" data-html=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 onload=\"this.contentDocument.open();this.contentDocument.write(atob(this.getAttribute('data-html')));this.contentDocument.close();\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"],"text/plain":["<folium.folium.Map at 0x7f2d36027438>"]},"metadata":{"tags":[]},"execution_count":7}]},{"cell_type":"markdown","metadata":{"id":"1EgflieqCiSB","colab_type":"text"},"source":["## Contoh Operasi Citra GEE dengan Google Colab\n","\n","Berikut adalah contoh beberapa operasi citra yang dapat dilakukan dengan menggunakan Google Colab. Contoh yang lebih lengkap dapat diakses pada dokumentasi resmi [EarthEngine Python API](https://developers.google.com/earth-engine/python_install), atau dapat dilihat pada: https://github.com/giswqs/earthengine-py-notebooks.\n","\n","Beberapa contoh berikut diperoleh dari https://github.com/csaybar/EEwPython"]},{"cell_type":"markdown","metadata":{"id":"R48ctyD2Dhae","colab_type":"text"},"source":["### Menampilkan Metadata Citra"]},{"cell_type":"code","metadata":{"id":"_5BGJ3M8DolL","colab_type":"code","outputId":"c903f7e2-747a-4455-adde-95258d9c4aaf","executionInfo":{"status":"ok","timestamp":1589328497212,"user_tz":-420,"elapsed":74639,"user":{"displayName":"Dany Puguh Laksono","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gjd8eOzv4V9R3fnhZHMJEN542UAJIK5XPlKWPS5=s64","userId":"10973890960709691040"}},"colab":{"base_uri":"https://localhost:8080/","height":68}},"source":["# Gunakan citra landsat tahun 2018 di Yogya\n","image = ee.Image('LANDSAT/LC08/C01/T1_TOA/LC08_120065_20180505')\n","\n","# mencetak daftar band\n","bandNames = image.bandNames()\n","print('Band names: ', bandNames.getInfo()) \n","\n","# Cetak Ukuran Pixel dalam meter\n","b1scale = image.select('B1').projection().nominalScale()\n","print('Band 1 scale: \\n', b1scale.getInfo()) # ee.Number"],"execution_count":0,"outputs":[{"output_type":"stream","text":["Band names:  ['B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7', 'B8', 'B9', 'B10', 'B11', 'BQA']\n","Band 1 scale: \n"," 30\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"id":"6aYUYbLhGH0N","colab_type":"code","outputId":"7a3419a3-b664-402f-b80c-53ba49becbd2","executionInfo":{"status":"ok","timestamp":1589328497214,"user_tz":-420,"elapsed":74623,"user":{"displayName":"Dany Puguh Laksono","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gjd8eOzv4V9R3fnhZHMJEN542UAJIK5XPlKWPS5=s64","userId":"10973890960709691040"}},"colab":{"base_uri":"https://localhost:8080/","height":1000}},"source":["# Menampilkan seluruh metadata\n","properties = image.propertyNames()\n","print('Metadata properties:', ) \n","properties.getInfo() # ee.List of metadata properties"],"execution_count":0,"outputs":[{"output_type":"stream","text":["Metadata properties:\n"],"name":"stdout"},{"output_type":"execute_result","data":{"text/plain":["['system:version',\n"," 'system:id',\n"," 'RADIANCE_MULT_BAND_5',\n"," 'RADIANCE_MULT_BAND_6',\n"," 'RADIANCE_MULT_BAND_3',\n"," 'RADIANCE_MULT_BAND_4',\n"," 'RADIANCE_MULT_BAND_1',\n"," 'RADIANCE_MULT_BAND_2',\n"," 'K2_CONSTANT_BAND_11',\n"," 'K2_CONSTANT_BAND_10',\n"," 'system:footprint',\n"," 'REFLECTIVE_SAMPLES',\n"," 'SUN_AZIMUTH',\n"," 'CPF_NAME',\n"," 'DATE_ACQUIRED',\n"," 'ELLIPSOID',\n"," 'google:registration_offset_x',\n"," 'google:registration_offset_y',\n"," 'STATION_ID',\n"," 'RESAMPLING_OPTION',\n"," 'ORIENTATION',\n"," 'WRS_ROW',\n"," 'RADIANCE_MULT_BAND_9',\n"," 'TARGET_WRS_ROW',\n"," 'RADIANCE_MULT_BAND_7',\n"," 'RADIANCE_MULT_BAND_8',\n"," 'IMAGE_QUALITY_TIRS',\n"," 'TRUNCATION_OLI',\n"," 'CLOUD_COVER',\n"," 'GEOMETRIC_RMSE_VERIFY',\n"," 'COLLECTION_CATEGORY',\n"," 'GRID_CELL_SIZE_REFLECTIVE',\n"," 'CLOUD_COVER_LAND',\n"," 'GEOMETRIC_RMSE_MODEL',\n"," 'COLLECTION_NUMBER',\n"," 'IMAGE_QUALITY_OLI',\n"," 'LANDSAT_SCENE_ID',\n"," 'WRS_PATH',\n"," 'google:registration_count',\n"," 'PANCHROMATIC_SAMPLES',\n"," 'PANCHROMATIC_LINES',\n"," 'GEOMETRIC_RMSE_MODEL_Y',\n"," 'REFLECTIVE_LINES',\n"," 'TIRS_STRAY_LIGHT_CORRECTION_SOURCE',\n"," 'GEOMETRIC_RMSE_MODEL_X',\n"," 'system:asset_size',\n"," 'system:index',\n"," 'REFLECTANCE_ADD_BAND_1',\n"," 'REFLECTANCE_ADD_BAND_2',\n"," 'DATUM',\n"," 'REFLECTANCE_ADD_BAND_3',\n"," 'REFLECTANCE_ADD_BAND_4',\n"," 'RLUT_FILE_NAME',\n"," 'REFLECTANCE_ADD_BAND_5',\n"," 'REFLECTANCE_ADD_BAND_6',\n"," 'REFLECTANCE_ADD_BAND_7',\n"," 'REFLECTANCE_ADD_BAND_8',\n"," 'BPF_NAME_TIRS',\n"," 'GROUND_CONTROL_POINTS_VERSION',\n"," 'DATA_TYPE',\n"," 'UTM_ZONE',\n"," 'LANDSAT_PRODUCT_ID',\n"," 'REFLECTANCE_ADD_BAND_9',\n"," 'google:registration_ratio',\n"," 'GRID_CELL_SIZE_PANCHROMATIC',\n"," 'RADIANCE_ADD_BAND_4',\n"," 'REFLECTANCE_MULT_BAND_7',\n"," 'system:time_start',\n"," 'RADIANCE_ADD_BAND_5',\n"," 'REFLECTANCE_MULT_BAND_6',\n"," 'RADIANCE_ADD_BAND_6',\n"," 'REFLECTANCE_MULT_BAND_9',\n"," 'PROCESSING_SOFTWARE_VERSION',\n"," 'RADIANCE_ADD_BAND_7',\n"," 'REFLECTANCE_MULT_BAND_8',\n"," 'RADIANCE_ADD_BAND_1',\n"," 'RADIANCE_ADD_BAND_2',\n"," 'RADIANCE_ADD_BAND_3',\n"," 'REFLECTANCE_MULT_BAND_1',\n"," 'RADIANCE_ADD_BAND_8',\n"," 'REFLECTANCE_MULT_BAND_3',\n"," 'RADIANCE_ADD_BAND_9',\n"," 'REFLECTANCE_MULT_BAND_2',\n"," 'REFLECTANCE_MULT_BAND_5',\n"," 'REFLECTANCE_MULT_BAND_4',\n"," 'THERMAL_LINES',\n"," 'TIRS_SSM_POSITION_STATUS',\n"," 'GRID_CELL_SIZE_THERMAL',\n"," 'NADIR_OFFNADIR',\n"," 'RADIANCE_ADD_BAND_11',\n"," 'REQUEST_ID',\n"," 'EARTH_SUN_DISTANCE',\n"," 'TIRS_SSM_MODEL',\n"," 'FILE_DATE',\n"," 'SCENE_CENTER_TIME',\n"," 'SUN_ELEVATION',\n"," 'BPF_NAME_OLI',\n"," 'RADIANCE_ADD_BAND_10',\n"," 'ROLL_ANGLE',\n"," 'K1_CONSTANT_BAND_10',\n"," 'SATURATION_BAND_1',\n"," 'SATURATION_BAND_2',\n"," 'SATURATION_BAND_3',\n"," 'SATURATION_BAND_4',\n"," 'SATURATION_BAND_5',\n"," 'MAP_PROJECTION',\n"," 'SATURATION_BAND_6',\n"," 'SENSOR_ID',\n"," 'SATURATION_BAND_7',\n"," 'K1_CONSTANT_BAND_11',\n"," 'SATURATION_BAND_8',\n"," 'SATURATION_BAND_9',\n"," 'TARGET_WRS_PATH',\n"," 'RADIANCE_MULT_BAND_11',\n"," 'RADIANCE_MULT_BAND_10',\n"," 'GROUND_CONTROL_POINTS_MODEL',\n"," 'SPACECRAFT_ID',\n"," 'ELEVATION_SOURCE',\n"," 'THERMAL_SAMPLES',\n"," 'GROUND_CONTROL_POINTS_VERIFY',\n"," 'system:bands',\n"," 'system:band_names']"]},"metadata":{"tags":[]},"execution_count":9}]},{"cell_type":"code","metadata":{"id":"XV10QZluGRum","colab_type":"code","outputId":"f493e97e-a74c-47b3-a405-86ee050f7409","executionInfo":{"status":"ok","timestamp":1589328497617,"user_tz":-420,"elapsed":75007,"user":{"displayName":"Dany Puguh Laksono","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gjd8eOzv4V9R3fnhZHMJEN542UAJIK5XPlKWPS5=s64","userId":"10973890960709691040"}},"colab":{"base_uri":"https://localhost:8080/","height":51}},"source":["# Memanggil metadata tertentu\n","cloudiness = image.get('CLOUD_COVER')\n","#path = image.get('WRS_PATH')\n","#row = image.get('WRS_ROW')\n","print('CLOUD_COVER: ')\n","cloudiness.getInfo() # ee.Number\n","\n"],"execution_count":0,"outputs":[{"output_type":"stream","text":["CLOUD_COVER: \n"],"name":"stdout"},{"output_type":"execute_result","data":{"text/plain":["0.7900000214576721"]},"metadata":{"tags":[]},"execution_count":10}]},{"cell_type":"code","metadata":{"id":"tUcQMx6VGd8x","colab_type":"code","outputId":"72201a06-db77-4601-cd58-020c4200a7dc","executionInfo":{"status":"ok","timestamp":1589328498346,"user_tz":-420,"elapsed":75719,"user":{"displayName":"Dany Puguh Laksono","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gjd8eOzv4V9R3fnhZHMJEN542UAJIK5XPlKWPS5=s64","userId":"10973890960709691040"}},"colab":{"base_uri":"https://localhost:8080/","height":34}},"source":["# menampilkan tanggal akuisisi citra\n","\n","from datetime import datetime as dt\n","\n","# Get the timestamp and convert it to a date.\n","date = ee.Date(image.get('system:time_start'))\n","# We divide by 1000 because Earth Engine returns the timestamp in milisecond and Python in seconds.\n","tmstp = date.getInfo()['value']/1000 \n","\n","print('Timestamp:', dt.utcfromtimestamp(tmstp).strftime('%Y-%m-%d %H:%M:%S'))"],"execution_count":0,"outputs":[{"output_type":"stream","text":["Timestamp: 2018-05-05 02:47:15\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"HFPJbNZeIGi-","colab_type":"text"},"source":["### Menampilkan NDVI\n"]},{"cell_type":"code","metadata":{"id":"2IwqXmtOIKRU","colab_type":"code","outputId":"5f373ff8-c478-4ccc-9649-b7f48a5f62d9","executionInfo":{"status":"ok","timestamp":1589328498999,"user_tz":-420,"elapsed":76356,"user":{"displayName":"Dany Puguh Laksono","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gjd8eOzv4V9R3fnhZHMJEN542UAJIK5XPlKWPS5=s64","userId":"10973890960709691040"}},"colab":{"base_uri":"https://localhost:8080/","height":583}},"source":["# Load two 5-year Landsat 7 composites.\n","landsat1999 = ee.Image('LANDSAT/LE7_TOA_5YEAR/1999_2003')\n","landsat2008 = ee.Image('LANDSAT/LE7_TOA_5YEAR/2008_2012')\n","\n","# Compute NDVI \n","ndvi1999 = landsat1999.normalizedDifference(['B4', 'B3'])\n","ndvi2008 = landsat2008.normalizedDifference(['B4', 'B3'])\n","\n","#Vizualization\n","ndwiViz = {'min': 0, 'max': 1, 'palette': ['FF0000', '00FF00']}\n","Jogja = ee.Geometry.Rectangle(\t110.0089, -8.2414, 110.8603, -7.4959)\n","\n","ndvi1999 = ndvi1999.clip(Jogja)\n","ndvi2008 = ndvi2008.clip(Jogja)\n","\n","tiles = {\n","    \"NDVI Jogja 1999\": ndvi1999.getMapId(ndwiViz), \n","    \"NDVI Jogja 2008\": ndvi2008.getMapId(ndwiViz)\n","}\n","\n","center=[-7.8226, 110.3851]\n","Mapdisplay(center, tiles)"],"execution_count":0,"outputs":[{"output_type":"execute_result","data":{"text/html":["<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><span style=\"color:#565656\">Make this Notebook Trusted to load map: File -> Trust Notebook</span><iframe src=\"about:blank\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" data-html=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 onload=\"this.contentDocument.open();this.contentDocument.write(atob(this.getAttribute('data-html')));this.contentDocument.close();\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"],"text/plain":["<folium.folium.Map at 0x7f2d360dae48>"]},"metadata":{"tags":[]},"execution_count":12}]},{"cell_type":"markdown","metadata":{"id":"XEMo1np5l8g4","colab_type":"text"},"source":["### Menampilkan EVI dengan Expression"]},{"cell_type":"code","metadata":{"id":"5XfVSkyumpZ1","colab_type":"code","outputId":"c8646130-7bb0-47dd-a6cd-e68913dbf08f","executionInfo":{"status":"ok","timestamp":1589328499000,"user_tz":-420,"elapsed":76336,"user":{"displayName":"Dany Puguh Laksono","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gjd8eOzv4V9R3fnhZHMJEN542UAJIK5XPlKWPS5=s64","userId":"10973890960709691040"}},"colab":{"base_uri":"https://localhost:8080/","height":583}},"source":["# Compute the EVI using an expression.\n","evi = image.expression(\n","      '2.5 * ((NIR - RED) / (NIR + 6 * RED - 7.5 * BLUE + 1))', {\n","      'NIR': image.select('B5'),\n","      'RED': image.select('B4'),\n","      'BLUE': image.select('B2')})\n","\n","#Display the map with folium!\n","Eviviz = {'min': 0, 'max': 1, 'palette': ['FF0000', '00FF00']}\n","tiles = {\"EVI 2014\": evi.getMapId(Eviviz)}\n","\n","Mapdisplay(center, tiles)"],"execution_count":0,"outputs":[{"output_type":"execute_result","data":{"text/html":["<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><span style=\"color:#565656\">Make this Notebook Trusted to load map: File -> Trust Notebook</span><iframe src=\"about:blank\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" data-html=PCFET0NUWVBFIGh0bWw+CjxoZWFkPiAgICAKICAgIDxtZXRhIGh0dHAtZXF1aXY9ImNvbnRlbnQtdHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PVVURi04IiAvPgogICAgCiAgICAgICAgPHNjcmlwdD4KICAgICAgICAgICAgTF9OT19UT1VDSCA9IGZhbHNlOwogICAgICAgICAgICBMX0RJU0FCTEVfM0QgPSBmYWxzZTsKICAgICAgICA8L3NjcmlwdD4KICAgIAogICAgPHNjcmlwdCBzcmM9Imh0dHBzOi8vY2RuLmpzZGVsaXZyLm5ldC9ucG0vbGVhZmxldEAxLjYuMC9kaXN0L2xlYWZsZXQuanMiPjwvc2NyaXB0PgogICAgPHNjcmlwdCBzcmM9Imh0dHBzOi8vY29kZS5qcXVlcnkuY29tL2pxdWVyeS0xLjEyLjQubWluLmpzIj48L3NjcmlwdD4KICAgIDxzY3JpcHQgc3JjPSJodHRwczovL21heGNkbi5ib290c3RyYXBjZG4uY29tL2Jvb3RzdHJhcC8zLjIuMC9qcy9ib290c3RyYXAubWluLmpzIj48L3NjcmlwdD4KICAgIDxzY3JpcHQgc3JjPSJodHRwczovL2NkbmpzLmNsb3VkZmxhcmUuY29tL2FqYXgvbGlicy9MZWFmbGV0LmF3ZXNvbWUtbWFya2Vycy8yLjAuMi9sZWFmbGV0LmF3ZXNvbWUtbWFya2Vycy5qcyI+PC9zY3JpcHQ+CiAgICA8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Imh0dHBzOi8vY2RuLmpzZGVsaXZyLm5ldC9ucG0vbGVhZmxldEAxLjYuMC9kaXN0L2xlYWZsZXQuY3NzIi8+CiAgICA8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Imh0dHBzOi8vbWF4Y2RuLmJvb3RzdHJhcGNkbi5jb20vYm9vdHN0cmFwLzMuMi4wL2Nzcy9ib290c3RyYXAubWluLmNzcyIvPgogICAgPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJodHRwczovL21heGNkbi5ib290c3RyYXBjZG4uY29tL2Jvb3RzdHJhcC8zLjIuMC9jc3MvYm9vdHN0cmFwLXRoZW1lLm1pbi5jc3MiLz4KICAgIDxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iaHR0cHM6Ly9tYXhjZG4uYm9vdHN0cmFwY2RuLmNvbS9mb250LWF3ZXNvbWUvNC42LjMvY3NzL2ZvbnQtYXdlc29tZS5taW4uY3NzIi8+CiAgICA8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Imh0dHBzOi8vY2RuanMuY2xvdWRmbGFyZS5jb20vYWpheC9saWJzL0xlYWZsZXQuYXdlc29tZS1tYXJrZXJzLzIuMC4yL2xlYWZsZXQuYXdlc29tZS1tYXJrZXJzLmNzcyIvPgogICAgPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJodHRwczovL3Jhd2Nkbi5naXRoYWNrLmNvbS9weXRob24tdmlzdWFsaXphdGlvbi9mb2xpdW0vbWFzdGVyL2ZvbGl1bS90ZW1wbGF0ZXMvbGVhZmxldC5hd2Vzb21lLnJvdGF0ZS5jc3MiLz4KICAgIDxzdHlsZT5odG1sLCBib2R5IHt3aWR0aDogMTAwJTtoZWlnaHQ6IDEwMCU7bWFyZ2luOiAwO3BhZGRpbmc6IDA7fTwvc3R5bGU+CiAgICA8c3R5bGU+I21hcCB7cG9zaXRpb246YWJzb2x1dGU7dG9wOjA7Ym90dG9tOjA7cmlnaHQ6MDtsZWZ0OjA7fTwvc3R5bGU+CiAgICAKICAgICAgICAgICAgPG1ldGEgbmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9IndpZHRoPWRldmljZS13aWR0aCwKICAgICAgICAgICAgICAgIGluaXRpYWwtc2NhbGU9MS4wLCBtYXhpbXVtLXNjYWxlPTEuMCwgdXNlci1zY2FsYWJsZT1ubyIgLz4KICAgICAgICAgICAgPHN0eWxlPgogICAgICAgICAgICAgICAgI21hcF80ZmI3ODIwMWRlMGI0OTY1OTYxMGM5YTkwZmMwY2EyYyB7CiAgICAgICAgICAgICAgICAgICAgcG9zaXRpb246IHJlbGF0aXZlOwogICAgICAgICAgICAgICAgICAgIHdpZHRoOiAxMDAuMCU7CiAgICAgICAgICAgICAgICAgICAgaGVpZ2h0OiAxMDAuMCU7CiAgICAgICAgICAgICAgICAgICAgbGVmdDogMC4wJTsKICAgICAgICAgICAgICAgICAgICB0b3A6IDAuMCU7CiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgIDwvc3R5bGU+CiAgICAgICAgCjwvaGVhZD4KPGJvZHk+ICAgIAogICAgCiAgICAgICAgICAgIDxkaXYgY2xhc3M9ImZvbGl1bS1tYXAiIGlkPSJtYXBfNGZiNzgyMDFkZTBiNDk2NTk2MTBjOWE5MGZjMGNhMmMiID48L2Rpdj4KICAgICAgICAKPC9ib2R5Pgo8c2NyaXB0PiAgICAKICAgIAogICAgICAgICAgICB2YXIgbWFwXzRmYjc4MjAxZGUwYjQ5NjU5NjEwYzlhOTBmYzBjYTJjID0gTC5tYXAoCiAgICAgICAgICAgICAgICAibWFwXzRmYjc4MjAxZGUwYjQ5NjU5NjEwYzlhOTBmYzBjYTJjIiwKICAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgICBjZW50ZXI6IFstNy44MjI2LCAxMTAuMzg1MV0sCiAgICAgICAgICAgICAgICAgICAgY3JzOiBMLkNSUy5FUFNHMzg1NywKICAgICAgICAgICAgICAgICAgICB6b29tOiAxMCwKICAgICAgICAgICAgICAgICAgICB6b29tQ29udHJvbDogdHJ1ZSwKICAgICAgICAgICAgICAgICAgICBwcmVmZXJDYW52YXM6IGZhbHNlLAogICAgICAgICAgICAgICAgfQogICAgICAgICAgICApOwoKICAgICAgICAgICAgCgogICAgICAgIAogICAgCiAgICAgICAgICAgIHZhciB0aWxlX2xheWVyXzQ3YWUwNTE2YmU1ZTQyZjVhY2JjZWQ2ZDEyOTkyOTllID0gTC50aWxlTGF5ZXIoCiAgICAgICAgICAgICAgICAiaHR0cHM6Ly97c30udGlsZS5vcGVuc3RyZWV0bWFwLm9yZy97en0ve3h9L3t5fS5wbmciLAogICAgICAgICAgICAgICAgeyJhdHRyaWJ1dGlvbiI6ICJEYXRhIGJ5IFx1MDAyNmNvcHk7IFx1MDAzY2EgaHJlZj1cImh0dHA6Ly9vcGVuc3RyZWV0bWFwLm9yZ1wiXHUwMDNlT3BlblN0cmVldE1hcFx1MDAzYy9hXHUwMDNlLCB1bmRlciBcdTAwM2NhIGhyZWY9XCJodHRwOi8vd3d3Lm9wZW5zdHJlZXRtYXAub3JnL2NvcHlyaWdodFwiXHUwMDNlT0RiTFx1MDAzYy9hXHUwMDNlLiIsICJkZXRlY3RSZXRpbmEiOiBmYWxzZSwgIm1heE5hdGl2ZVpvb20iOiAxOCwgIm1heFpvb20iOiAxOCwgIm1pblpvb20iOiAwLCAibm9XcmFwIjogZmFsc2UsICJvcGFjaXR5IjogMSwgInN1YmRvbWFpbnMiOiAiYWJjIiwgInRtcyI6IGZhbHNlfQogICAgICAgICAgICApLmFkZFRvKG1hcF80ZmI3ODIwMWRlMGI0OTY1OTYxMGM5YTkwZmMwY2EyYyk7CiAgICAgICAgCiAgICAKICAgICAgICAgICAgdmFyIHRpbGVfbGF5ZXJfZmZmMWFmMmZhNTg3NDE2ZTliZWY1OGU2MTZjYzhkM2UgPSBMLnRpbGVMYXllcigKICAgICAgICAgICAgICAgICJodHRwczovL2VhcnRoZW5naW5lLmdvb2dsZWFwaXMuY29tL3YxYWxwaGEvcHJvamVjdHMvZWFydGhlbmdpbmUtbGVnYWN5L21hcHMvNWY1NDlhYjBhMzMwZTE2ZTkyNDlkYWY5ZGZhZjhjZGEtZjM3MzY0NDk2YzhiMzlmYzZhOGMwYThmMmZkZTA2ZjcvdGlsZXMve3p9L3t4fS97eX0iLAogICAgICAgICAgICAgICAgeyJhdHRyaWJ1dGlvbiI6ICJHb29nbGUgRWFydGggRW5naW5lIiwgImRldGVjdFJldGluYSI6IGZhbHNlLCAibWF4TmF0aXZlWm9vbSI6IDE4LCAibWF4Wm9vbSI6IDE4LCAibWluWm9vbSI6IDAsICJub1dyYXAiOiBmYWxzZSwgIm9wYWNpdHkiOiAxLCAic3ViZG9tYWlucyI6ICJhYmMiLCAidG1zIjogZmFsc2V9CiAgICAgICAgICAgICkuYWRkVG8obWFwXzRmYjc4MjAxZGUwYjQ5NjU5NjEwYzlhOTBmYzBjYTJjKTsKICAgICAgICAKICAgIAogICAgICAgICAgICB2YXIgbGF5ZXJfY29udHJvbF82MWM3MTlmMjg2Mjg0NjdlOTRiODdhNGJkNzI1MTZiNCA9IHsKICAgICAgICAgICAgICAgIGJhc2VfbGF5ZXJzIDogewogICAgICAgICAgICAgICAgICAgICJvcGVuc3RyZWV0bWFwIiA6IHRpbGVfbGF5ZXJfNDdhZTA1MTZiZTVlNDJmNWFjYmNlZDZkMTI5OTI5OWUsCiAgICAgICAgICAgICAgICB9LAogICAgICAgICAgICAgICAgb3ZlcmxheXMgOiAgewogICAgICAgICAgICAgICAgICAgICJFVkkgMjAxNCIgOiB0aWxlX2xheWVyX2ZmZjFhZjJmYTU4NzQxNmU5YmVmNThlNjE2Y2M4ZDNlLAogICAgICAgICAgICAgICAgfSwKICAgICAgICAgICAgfTsKICAgICAgICAgICAgTC5jb250cm9sLmxheWVycygKICAgICAgICAgICAgICAgIGxheWVyX2NvbnRyb2xfNjFjNzE5ZjI4NjI4NDY3ZTk0Yjg3YTRiZDcyNTE2YjQuYmFzZV9sYXllcnMsCiAgICAgICAgICAgICAgICBsYXllcl9jb250cm9sXzYxYzcxOWYyODYyODQ2N2U5NGI4N2E0YmQ3MjUxNmI0Lm92ZXJsYXlzLAogICAgICAgICAgICAgICAgeyJhdXRvWkluZGV4IjogdHJ1ZSwgImNvbGxhcHNlZCI6IHRydWUsICJwb3NpdGlvbiI6ICJ0b3ByaWdodCJ9CiAgICAgICAgICAgICkuYWRkVG8obWFwXzRmYjc4MjAxZGUwYjQ5NjU5NjEwYzlhOTBmYzBjYTJjKTsKICAgICAgICAKPC9zY3JpcHQ+ onload=\"this.contentDocument.open();this.contentDocument.write(atob(this.getAttribute('data-html')));this.contentDocument.close();\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"],"text/plain":["<folium.folium.Map at 0x7f2d35a724e0>"]},"metadata":{"tags":[]},"execution_count":13}]},{"cell_type":"markdown","metadata":{"id":"9QXTEMQRnAh0","colab_type":"text"},"source":["### Operasi Boolean \n","\n","Ekstraksi Bare Earth dari kondisi NDVi dan badan air"]},{"cell_type":"code","metadata":{"id":"7NQ4JnUonJs0","colab_type":"code","outputId":"ee8cd148-c4ec-4646-efff-92872ec5c39b","executionInfo":{"status":"ok","timestamp":1589328499002,"user_tz":-420,"elapsed":76311,"user":{"displayName":"Dany Puguh Laksono","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gjd8eOzv4V9R3fnhZHMJEN542UAJIK5XPlKWPS5=s64","userId":"10973890960709691040"}},"colab":{"base_uri":"https://localhost:8080/","height":583}},"source":["# Create NDVI and NDWI spectral indices.\n","ndvi = image.normalizedDifference(['B5', 'B4'])\n","ndwi = image.normalizedDifference(['B3', 'B5'])\n","\n","# Create a binary layer using logical operations.\n","# lt = lower than\n","bare = ndvi.lt(0.2).And(ndwi.lt(0))\n","\n","bare = bare.updateMask(bare)\n","BareId = bare.getMapId()\n","\n","tiles = {\"Bare\": BareId}\n","Mapdisplay(center, tiles, \"Stamen Terrain\")"],"execution_count":0,"outputs":[{"output_type":"execute_result","data":{"text/html":["<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><span style=\"color:#565656\">Make this Notebook Trusted to load map: File -> Trust Notebook</span><iframe src=\"about:blank\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" data-html=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 onload=\"this.contentDocument.open();this.contentDocument.write(atob(this.getAttribute('data-html')));this.contentDocument.close();\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"],"text/plain":["<folium.folium.Map at 0x7f2d35a100b8>"]},"metadata":{"tags":[]},"execution_count":14}]},{"cell_type":"markdown","metadata":{"id":"_Onnt_eYnjlB","colab_type":"text"},"source":["### Thresholding dengan operator Boolean\n","\n","Zona urbanisasi berdasarkan sebaran cahaya malam hari"]},{"cell_type":"code","metadata":{"id":"LBzh9FI2nn6b","colab_type":"code","outputId":"050d8843-31aa-45c9-c467-2b5bbae4dc51","executionInfo":{"status":"ok","timestamp":1589328499786,"user_tz":-420,"elapsed":77075,"user":{"displayName":"Dany Puguh Laksono","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gjd8eOzv4V9R3fnhZHMJEN542UAJIK5XPlKWPS5=s64","userId":"10973890960709691040"}},"colab":{"base_uri":"https://localhost:8080/","height":583}},"source":["# Load a 2012 nightlights image.\n","nl2012 = ee.Image('NOAA/DMSP-OLS/NIGHTTIME_LIGHTS/F182012')\n","lights = nl2012.select('stable_lights')\n","\n","# Define arbitrary thresholds on the 6-bit stable lights band.\n","zones = lights.gt(30).add(lights.gt(55)).add(lights.gt(62))\n","\n","# Display the thresholded image as three distinct zones near Paris.\n","palette = ['000000', '0000FF', '00FF00', 'FF0000']\n","\n","\n","zonesId = zones.getMapId({'min': 0, 'max': 3, 'palette': palette})\n","tiles = {\"Zonas\": zonesId}\n","\n","Mapdisplay(center, tiles)"],"execution_count":0,"outputs":[{"output_type":"execute_result","data":{"text/html":["<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><span style=\"color:#565656\">Make this Notebook Trusted to load map: File -> Trust Notebook</span><iframe src=\"about:blank\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" data-html=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 onload=\"this.contentDocument.open();this.contentDocument.write(atob(this.getAttribute('data-html')));this.contentDocument.close();\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"],"text/plain":["<folium.folium.Map at 0x7f2d35a2aeb8>"]},"metadata":{"tags":[]},"execution_count":15}]},{"cell_type":"markdown","metadata":{"id":"Br1GUJ1BE009","colab_type":"text"},"source":["### Menggunakan Reducer"]},{"cell_type":"code","metadata":{"id":"P2bjKzrdE3zg","colab_type":"code","outputId":"14181df2-34db-4a5f-fa78-7b01537ea926","executionInfo":{"status":"ok","timestamp":1589328500347,"user_tz":-420,"elapsed":77613,"user":{"displayName":"Dany Puguh Laksono","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gjd8eOzv4V9R3fnhZHMJEN542UAJIK5XPlKWPS5=s64","userId":"10973890960709691040"}},"colab":{"base_uri":"https://localhost:8080/","height":583}},"source":["# Load an image collection, filtered so it's not too much data.\n","collection = ee.ImageCollection('LANDSAT/LC08/C01/T1_TOA')\\\n","               .filterDate('2018-01-01', '2019-12-31')\\\n","               .filter(ee.Filter.eq('WRS_PATH', 120))\\\n","               .filter(ee.Filter.eq('WRS_ROW', 65))\n","\n","# Compute the median in each band, each pixel.\n","# Band names are B1_median, B2_median, etc.\n","median = collection.reduce(ee.Reducer.median())\n","\n","# The output is an Image.  Add it to the map.\n","vis_param = {'bands': ['B4_median', 'B3_median', 'B2_median'], 'max': 0.4}\n","median_tk = median.getMapId(vis_param)\n","\n","Mapdisplay(center,{'Median Landsat 8':median_tk},zoom_start=9)"],"execution_count":0,"outputs":[{"output_type":"execute_result","data":{"text/html":["<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><span style=\"color:#565656\">Make this Notebook Trusted to load map: File -> Trust Notebook</span><iframe src=\"about:blank\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" data-html=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 onload=\"this.contentDocument.open();this.contentDocument.write(atob(this.getAttribute('data-html')));this.contentDocument.close();\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"],"text/plain":["<folium.folium.Map at 0x7f2d35a30c50>"]},"metadata":{"tags":[]},"execution_count":16}]},{"cell_type":"markdown","metadata":{"id":"52zNHdwzpSeP","colab_type":"text"},"source":["### Pansharpening\n","\n","Pansharpening dilakukan dengan menukar band saturasi dari colorspace HSV dengan band pankromatik pada citra Landsat 8"]},{"cell_type":"code","metadata":{"id":"j4ORydrUpenw","colab_type":"code","outputId":"408eb2a8-c55e-4ef0-f86e-b897da551d32","executionInfo":{"status":"ok","timestamp":1589328500760,"user_tz":-420,"elapsed":78006,"user":{"displayName":"Dany Puguh Laksono","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gjd8eOzv4V9R3fnhZHMJEN542UAJIK5XPlKWPS5=s64","userId":"10973890960709691040"}},"colab":{"base_uri":"https://localhost:8080/","height":583}},"source":["\n","# Convert the RGB bands to the HSV color space.\n","hsv = image.select(['B4', 'B3', 'B2']).rgbToHsv()\n","\n","# Swap in the panchromatic band and convert back to RGB.\n","sharpened = ee.Image.cat([\n","  hsv.select('hue'), hsv.select('saturation'), image.select('B8')\n","]).hsvToRgb()\n","\n","# Display the results.\n","tiles = {\n","    'rgb': image.getMapId({'bands': ['B4', 'B3', 'B2'], \n","                           'min': 0, \n","                           'max': 0.25, \n","                           'gamma': [1.1, 1.1, 1]}),\n","    'pan-sharpened': sharpened.getMapId({'min': 0, \n","                                         'max': 0.25, \n","                                         'gamma': [1.3, 1.3, 1.3]})\n","}\n","\n","\n","Mapdisplay(center, tiles, \"Stamen Terrain\")"],"execution_count":0,"outputs":[{"output_type":"execute_result","data":{"text/html":["<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><span style=\"color:#565656\">Make this Notebook Trusted to load map: File -> Trust Notebook</span><iframe src=\"about:blank\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" data-html=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 onload=\"this.contentDocument.open();this.contentDocument.write(atob(this.getAttribute('data-html')));this.contentDocument.close();\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"],"text/plain":["<folium.folium.Map at 0x7f2d359c2668>"]},"metadata":{"tags":[]},"execution_count":17}]},{"cell_type":"markdown","metadata":{"id":"iCZvIeuDqKvV","colab_type":"text"},"source":["### Object Based"]},{"cell_type":"code","metadata":{"id":"iR121QFZqMYv","colab_type":"code","outputId":"d05523cb-2ed6-4279-ac0a-a57471d34192","executionInfo":{"status":"ok","timestamp":1589328501975,"user_tz":-420,"elapsed":79200,"user":{"displayName":"Dany Puguh Laksono","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gjd8eOzv4V9R3fnhZHMJEN542UAJIK5XPlKWPS5=s64","userId":"10973890960709691040"}},"colab":{"base_uri":"https://localhost:8080/","height":583}},"source":["# Threshold the thermal band to find \"hot\" objects.\n","hotspots = image.select('B10').gt(303)\n","\n","# Mask \"cold\" pixels.\n","hotspots = hotspots.updateMask(hotspots)\n","\n","# Compute the number of pixels in each patch.\n","patchsize = hotspots.connectedPixelCount(256, False)\n","\n","# Uniquely label the patches and visualize.\n","patchid = hotspots.connectedComponents(ee.Kernel.plus(1), 256)\n","    \n","# Display the results.\n","tiles = {\n","    \"LST\": image.getMapId({'bands': ['B10'], 'min': 270, 'max': 310}),\n","    \"hotspots\": hotspots.getMapId({'palette': 'FF0000'}),\n","    \"patchsize\": patchsize.getMapId(),\n","    \"patches\": patchid.getMapId()\n","}\n","\n","Mapdisplay(center, tiles, \"Stamen Terrain\")"],"execution_count":0,"outputs":[{"output_type":"execute_result","data":{"text/html":["<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><span style=\"color:#565656\">Make this Notebook Trusted to load map: File -> Trust Notebook</span><iframe src=\"about:blank\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" data-html=<!DOCTYPE html>
<head>    
    <meta http-equiv="content-type" content="text/html; charset=UTF-8" />
    
        <script>
            L_NO_TOUCH = false;
            L_DISABLE_3D = false;
        </script>
    
    <script src="https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.js"></script>
    <script src="https://code.jquery.com/jquery-1.12.4.min.js"></script>
    <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/js/bootstrap.min.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.js"></script>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.css"/>
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css"/>
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap-theme.min.css"/>
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.6.3/css/font-awesome.min.css"/>
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.css"/>
    <link rel="stylesheet" href="https://rawcdn.githack.com/python-visualization/folium/master/folium/templates/leaflet.awesome.rotate.css"/>
    <style>html, body {width: 100%;height: 100%;margin: 0;padding: 0;}</style>
    <style>#map {position:absolute;top:0;bottom:0;right:0;left:0;}</style>
    
            <meta name="viewport" content="width=device-width,
                initial-scale=1.0, maximum-scale=1.0, user-scalable=no" />
            <style>
                #map_1f69f8acab3842a19468319817ea07c9 {
                    position: relative;
                    width: 100.0%;
                    height: 100.0%;
                    left: 0.0%;
                    top: 0.0%;
                }
            </style>
        
</head>
<body>    
    
            <div class="folium-map" id="map_1f69f8acab3842a19468319817ea07c9" ></div>
        
</body>
<script>    
    
            var map_1f69f8acab3842a19468319817ea07c9 = L.map(
                "map_1f69f8acab3842a19468319817ea07c9",
                {
                    center: [-7.8226, 110.3851],
                    crs: L.CRS.EPSG3857,
                    zoom: 10,
                    zoomControl: true,
                    preferCanvas: false,
                }
            );

            

        
    
            var tile_layer_48cde52af368445d85f3cd496d3020cb = L.tileLayer(
                "https://stamen-tiles-{s}.a.ssl.fastly.net/terrain/{z}/{x}/{y}.jpg",
                {"attribution": "Map tiles by \u003ca href=\"http://stamen.com\"\u003eStamen Design\u003c/a\u003e, under \u003ca href=\"http://creativecommons.org/licenses/by/3.0\"\u003eCC BY 3.0\u003c/a\u003e. Data by \u0026copy; \u003ca href=\"http://openstreetmap.org\"\u003eOpenStreetMap\u003c/a\u003e, under \u003ca href=\"http://creativecommons.org/licenses/by-sa/3.0\"\u003eCC BY SA\u003c/a\u003e.", "detectRetina": false, "maxNativeZoom": 18, "maxZoom": 18, "minZoom": 0, "noWrap": false, "opacity": 1, "subdomains": "abc", "tms": false}
            ).addTo(map_1f69f8acab3842a19468319817ea07c9);
        
    
            var tile_layer_b630eeb6c6af4e6c84911ab1a1ffde82 = L.tileLayer(
                "https://earthengine.googleapis.com/v1alpha/projects/earthengine-legacy/maps/a0d9e293ea15acac350e0a840c40b079-2ed676fa58651999c6b4b76750c8e643/tiles/{z}/{x}/{y}",
                {"attribution": "Google Earth Engine", "detectRetina": false, "maxNativeZoom": 18, "maxZoom": 18, "minZoom": 0, "noWrap": false, "opacity": 1, "subdomains": "abc", "tms": false}
            ).addTo(map_1f69f8acab3842a19468319817ea07c9);
        
    
            var tile_layer_76d29e608ee54c1b98b938406172824d = L.tileLayer(
                "https://earthengine.googleapis.com/v1alpha/projects/earthengine-legacy/maps/78c6735d1d08587ef306c253f3af1bb8-a7fb3c6b851e45ad23123175a9e368f3/tiles/{z}/{x}/{y}",
                {"attribution": "Google Earth Engine", "detectRetina": false, "maxNativeZoom": 18, "maxZoom": 18, "minZoom": 0, "noWrap": false, "opacity": 1, "subdomains": "abc", "tms": false}
            ).addTo(map_1f69f8acab3842a19468319817ea07c9);
        
    
            var tile_layer_a8372739ef0547acae70999d26b99ae3 = L.tileLayer(
                "https://earthengine.googleapis.com/v1alpha/projects/earthengine-legacy/maps/cb936ddb8f9181bb54d513a07a1bafc8-58ea5d87db2410358cc64249f5e952c7/tiles/{z}/{x}/{y}",
                {"attribution": "Google Earth Engine", "detectRetina": false, "maxNativeZoom": 18, "maxZoom": 18, "minZoom": 0, "noWrap": false, "opacity": 1, "subdomains": "abc", "tms": false}
            ).addTo(map_1f69f8acab3842a19468319817ea07c9);
        
    
            var tile_layer_b0514fb6cff34536b2f53b05291b93b6 = L.tileLayer(
                "https://earthengine.googleapis.com/v1alpha/projects/earthengine-legacy/maps/9a008a2ea84cd139aae73697e9902e2c-10ddfaadfaf43f75a0f74822bf677308/tiles/{z}/{x}/{y}",
                {"attribution": "Google Earth Engine", "detectRetina": false, "maxNativeZoom": 18, "maxZoom": 18, "minZoom": 0, "noWrap": false, "opacity": 1, "subdomains": "abc", "tms": false}
            ).addTo(map_1f69f8acab3842a19468319817ea07c9);
        
    
            var layer_control_8b5673586c4845eaa946de374d4e4db4 = {
                base_layers : {
                    "stamenterrain" : tile_layer_48cde52af368445d85f3cd496d3020cb,
                },
                overlays :  {
                    "LST" : tile_layer_b630eeb6c6af4e6c84911ab1a1ffde82,
                    "hotspots" : tile_layer_76d29e608ee54c1b98b938406172824d,
                    "patchsize" : tile_layer_a8372739ef0547acae70999d26b99ae3,
                    "patches" : tile_layer_b0514fb6cff34536b2f53b05291b93b6,
                },
            };
            L.control.layers(
                layer_control_8b5673586c4845eaa946de374d4e4db4.base_layers,
                layer_control_8b5673586c4845eaa946de374d4e4db4.overlays,
                {"autoZIndex": true, "collapsed": true, "position": "topright"}
            ).addTo(map_1f69f8acab3842a19468319817ea07c9);
        
</script> onload=\"this.contentDocument.open();this.contentDocument.write(atob(this.getAttribute('data-html')));this.contentDocument.close();\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"],"text/plain":["<folium.folium.Map at 0x7f2d359cea90>"]},"metadata":{"tags":[]},"execution_count":18}]},{"cell_type":"markdown","metadata":{"id":"p0VKhgCvC1Kw","colab_type":"text"},"source":["### Klasifikasi Citra Supervised"]},{"cell_type":"code","metadata":{"id":"hDtCgffiC6jO","colab_type":"code","outputId":"88b83bae-d2db-4edb-a751-0d309fad8f2d","executionInfo":{"status":"error","timestamp":1589328502732,"user_tz":-420,"elapsed":79947,"user":{"displayName":"Dany Puguh Laksono","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gjd8eOzv4V9R3fnhZHMJEN542UAJIK5XPlKWPS5=s64","userId":"10973890960709691040"}},"colab":{"base_uri":"https://localhost:8080/","height":445}},"source":["# Use these bands for prediction.\n","bands = ['B2', 'B3', 'B4', 'B5', 'B6', 'B7', 'B10', 'B11']\n","\n","# Load an image over a portion of southern California, USA.\n","image = ee.Image('LANDSAT/LC08/C01/T1_TOA/LC08_040037_20131114')\\\n","          .select(bands)\n","\n","# Load training polygons from a Fusion Table.\n","# The 'class' property stores known class labels.\n","polygons = ee.FeatureCollection('ft:1vYn7-uO80vAVpZxi81yXzx55jgtztsZaLxG5TWYH')\n","\n","# Get the values for all pixels in each polygon in the training.\n","training = image.sampleRegions(\n","  collection=polygons,\n","  properties=['class'],\n","  scale=30)\n","\n","# Create an SVM classifier with custom parameters.\n","classifier = ee.Classifier.svm(\n","  kernelType='RBF',\n","  gamma=0.5,\n","  cost=10)\n","\n","# Train the classifier.\n","trained = classifier.train(training, 'class', bands)\n","\n","# Classify the image.\n","classified = image.classify(trained)\n","\n","# Create a palette to display the classes.\n","palette =['006400', '32CD32', 'EEE8AA',\n","          '8B4513', '98FB98', '00FA9A',\n","          '90EE90', '00008B', 'FF8C00',\n","          'ADFF2F', '808080']\n","\n","# Display the classification result and the input image.\n","center = [33.30, -117.3]\n","token_image = image.getMapId({'bands': ['B4', 'B3', 'B2'], 'max': 0.5, 'gamma': 2})\n","token_classified = classified.getMapId({'min': 0, 'max': 10, 'palette': palette})\n","Mapdisplay(center,{'LANDSAT':token_image,'Vegetation_Type':token_classified},zoom_start=9)"],"execution_count":0,"outputs":[{"output_type":"error","ename":"EEException","evalue":"ignored","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mHttpError\u001b[0m                                 Traceback (most recent call last)","\u001b[0;32m/usr/local/lib/python3.6/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    337\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--> 338\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    339\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[0;32m/usr/local/lib/python3.6/dist-packages/googleapiclient/_helpers.py\u001b[0m in \u001b[0;36mpositional_wrapper\u001b[0;34m(*args, **kwargs)\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[0;32m/usr/local/lib/python3.6/dist-packages/googleapiclient/http.py\u001b[0m in \u001b[0;36mexecute\u001b[0;34m(self, http, num_retries)\u001b[0m\n\u001b[1;32m    897\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mresp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstatus\u001b[0m \u001b[0;34m>=\u001b[0m \u001b[0;36m300\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 898\u001b[0;31m             \u001b[0;32mraise\u001b[0m \u001b[0mHttpError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcontent\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0muri\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0muri\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    899\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpostproc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcontent\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;31mHttpError\u001b[0m: <HttpError 400 when requesting https://earthengine.googleapis.com/v1alpha/projects/earthengine-legacy/maps?fields=name&alt=json returned \"Collection.loadTable: Collection asset 'ft:1vYn7-uO80vAVpZxi81yXzx55jgtztsZaLxG5TWYH' not found.\">","\nDuring handling of the above exception, another exception occurred:\n","\u001b[0;31mEEException\u001b[0m                               Traceback (most recent call last)","\u001b[0;32m<ipython-input-19-aed8117a38ab>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     36\u001b[0m \u001b[0mcenter\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m33.30\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m117.3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     37\u001b[0m \u001b[0mtoken_image\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mimage\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgetMapId\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0;34m'bands'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'B4'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'B3'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'B2'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'max'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;36m0.5\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'gamma'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;36m2\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---> 38\u001b[0;31m \u001b[0mtoken_classified\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mclassified\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgetMapId\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0;34m'min'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'max'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'palette'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mpalette\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     39\u001b[0m \u001b[0mMapdisplay\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcenter\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0;34m'LANDSAT'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mtoken_image\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'Vegetation_Type'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mtoken_classified\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mzoom_start\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m9\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.6/dist-packages/ee/image.py\u001b[0m in \u001b[0;36mgetMapId\u001b[0;34m(self, vis_params)\u001b[0m\n\u001b[1;32m    129\u001b[0m     \u001b[0mvis_image\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrequest\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_apply_visualization\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvis_params\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    130\u001b[0m     \u001b[0mrequest\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'image'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvis_image\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 131\u001b[0;31m     \u001b[0mresponse\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgetMapId\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrequest\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    132\u001b[0m     \u001b[0mresponse\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'image'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    133\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mresponse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.6/dist-packages/ee/data.py\u001b[0m in \u001b[0;36mgetMapId\u001b[0;34m(params)\u001b[0m\n\u001b[1;32m    589\u001b[0m         \u001b[0mparent\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[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    590\u001b[0m         \u001b[0mfields\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'name'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 591\u001b[0;31m         body=request))\n\u001b[0m\u001b[1;32m    592\u001b[0m     \u001b[0mmap_name\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'name'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    593\u001b[0m     url_format = '%s/%s/%s/tiles/{z}/{x}/{y}' % (\n","\u001b[0;32m/usr/local/lib/python3.6/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    338\u001b[0m     \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[1;32m    339\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[0;32m--> 340\u001b[0;31m     \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[0m\u001b[1;32m    341\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    342\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;31mEEException\u001b[0m: Collection.loadTable: Collection asset 'ft:1vYn7-uO80vAVpZxi81yXzx55jgtztsZaLxG5TWYH' not found."]}]},{"cell_type":"markdown","metadata":{"id":"UmhWDkL8sM6W","colab_type":"text"},"source":["## Menyimpan hasil operasi citra\n","\n","Hasil analisis yang sudah dibuat melalui Google Colab dengan server Google Earth Engine dapat disimpan ke Google Drive maupun sebagai asset di Google Earth"]},{"cell_type":"markdown","metadata":{"id":"3nYAu5lWws00","colab_type":"text"},"source":["### Menyimpan di Google Drive"]},{"cell_type":"code","metadata":{"id":"ObONMr3Uzy0F","colab_type":"code","colab":{}},"source":["# Mengizinkan akses  ke google drive\n","from google.colab import drive\n","drive.mount('/content/drive')"],"execution_count":0,"outputs":[]},{"cell_type":"code","metadata":{"id":"LK_f5w5r0pRO","colab_type":"code","colab":{}},"source":["# Load a landsat image and select three bands.\n","landsat = ee.Image('LANDSAT/LC08/C01/T1_TOA/LC08_120065_20180505')\\\n","            .select(['B4', 'B3', 'B2'])\n","\n","Jogja = ee.Geometry.Rectangle([110.0089, -8.2414, 110.8603, -7.4959])\n","print(Jogja.getInfo()['coordinates'])"],"execution_count":0,"outputs":[]},{"cell_type":"code","metadata":{"id":"YO9CXyNGwxAA","colab_type":"code","colab":{}},"source":["\n","task = ee.batch.Export.image.toDrive(**{\n","    'image': landsat,  #image yang akan dieksport. bisa juga hasil analisis\n","    'description': 'contohimagetodrive',\n","    'folder':'Folder_Hasil_GEE',\n","    'scale': 100,\n","    'region': Jogja.getInfo()['coordinates']\n","})\n","task.start()"],"execution_count":0,"outputs":[]},{"cell_type":"code","metadata":{"id":"rxFDfsQQzARM","colab_type":"code","colab":{}},"source":["import time \n","while task.active():\n","  print('Polling for task (id: {}).'.format(task.id))\n","  time.sleep(5)"],"execution_count":0,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"jdhv114B2Bbv","colab_type":"text"},"source":["### Menyimpan sebagai asset di GEE"]},{"cell_type":"code","metadata":{"id":"GfM3lexx2FXQ","colab_type":"code","colab":{}},"source":["# Get band 4 from the Landsat image, copy it.\n","band4 = landsat.select('B4').rename('b4_mean')\\\n","               .addBands(landsat.select('B4').rename('b4_sample'))\\\n","               .addBands(landsat.select('B4').rename('b4_max'))\\\n","\n","# Export the image to an Earth Engine asset.\n","task = ee.batch.Export.image.toAsset(**{\n","  'image': band4,\n","  'description': 'imageToAssetExample',\n","  'assetId': 'users/danylaksono/exampleExport',\n","  'scale': 100,\n","  'region': Jogja.getInfo()['coordinates']\n","})\n","task.start()"],"execution_count":0,"outputs":[]},{"cell_type":"code","metadata":{"id":"edFhQkTA2aqv","colab_type":"code","colab":{}},"source":["while task.active():\n","  print('Polling for task (id: {}).'.format(task.id))\n"," time.sleep(5)"],"execution_count":0,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"Eudo0p02SdT5","colab_type":"text"},"source":["## Menggunakan GEEMap Python\n","\n","GEEMap (https://github.com/giswqs/geemap) merupakan library Python yang dibuat oleh \n","Qiusheng Wu untuk menambahkan fitur-fitur antarmuka pada EarthEngine Python API. GEEMap dapat digunakan untuk memperkaya antarmuka dari EarthEngine yang dibuat dengan Python dengan memanfaatkan fungsi peta interaktif yang dimiliki oleh LeafletJS. Lebih jauh lagi, GEEMap dapat digunakan untuk mengeksport notebook berisi peta EarthEngine menjadi sebuah website.\n","\n","Seluruh tutorial untuk GEEMap dapat dilihat pada playlist Youtube berikut:\n","\n","https://www.youtube.com/playlist?list=PLAxJ4-o7ZoPccOFv1dCwvGI6TYnirRTg3\n","\n","Adapun tutorialnya dapat dilihat pada https://geemap.readthedocs.io/en/latest/"]},{"cell_type":"markdown","metadata":{"id":"ZSW7_gxuUczm","colab_type":"text"},"source":["### Instalasi dan pengaturan\n","\n","Panduan instalasi dan pengaturan GEEMAP pada Google Colab dapat dilihat [di sini](https://colab.research.google.com/github/giswqs/geemap/blob/master/examples/notebooks/geemap_and_folium.ipynb)\n","\n","Penggunaan GEEMap pada Google Colab memiliki beberapa perbedaan karena perbedaan fungsi iPyLeaflet. Berikut adalah dokumentasi untuk pemasangan GEEMap pada Google Colab: https://github.com/giswqs/geemap#usage"]},{"cell_type":"code","metadata":{"id":"BILRvKSmUBex","colab_type":"code","outputId":"f3fa2806-352d-46fc-a77e-7785f3cea541","executionInfo":{"status":"ok","timestamp":1589328652501,"user_tz":-420,"elapsed":5107,"user":{"displayName":"Dany Puguh Laksono","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gjd8eOzv4V9R3fnhZHMJEN542UAJIK5XPlKWPS5=s64","userId":"10973890960709691040"}},"colab":{"base_uri":"https://localhost:8080/","height":1000}},"source":["# Instalasi Geemap pada Google Colab\n","# karena bukan merupakan modul bawaan Google Colab, penggunaan GEEMap\n","# memerlukan instalasi terlebih dahulu\n","# Installs geemap package\n","!pip install geemap"],"execution_count":0,"outputs":[{"output_type":"stream","text":["Requirement already satisfied: geemap in /usr/local/lib/python3.6/dist-packages (0.6.13)\n","Requirement already satisfied: earthengine-api in /usr/local/lib/python3.6/dist-packages (from geemap) (0.1.221)\n","Requirement already satisfied: ipynb-py-convert in /usr/local/lib/python3.6/dist-packages (from geemap) (0.4.5)\n","Requirement already satisfied: ipyleaflet>=0.12.6 in /usr/local/lib/python3.6/dist-packages (from geemap) (0.12.6)\n","Requirement already satisfied: mss in /usr/local/lib/python3.6/dist-packages (from geemap) (5.1.0)\n","Requirement already satisfied: colour in /usr/local/lib/python3.6/dist-packages (from geemap) (0.1.5)\n","Requirement already satisfied: pyshp in /usr/local/lib/python3.6/dist-packages (from geemap) (2.1.0)\n","Requirement already satisfied: pillow in /usr/local/lib/python3.6/dist-packages (from geemap) (7.0.0)\n","Requirement already satisfied: bqplot in /usr/local/lib/python3.6/dist-packages (from geemap) (0.12.10)\n","Requirement already satisfied: ipyfilechooser in /usr/local/lib/python3.6/dist-packages (from geemap) (0.3.4)\n","Requirement already satisfied: folium>=0.11.0 in /usr/local/lib/python3.6/dist-packages (from geemap) (0.11.0)\n","Requirement already satisfied: click in /usr/local/lib/python3.6/dist-packages (from geemap) (7.1.2)\n","Requirement already satisfied: geocoder in /usr/local/lib/python3.6/dist-packages (from geemap) (1.38.1)\n","Requirement already satisfied: geeadd>=0.4.8 in /usr/local/lib/python3.6/dist-packages (from geemap) (0.4.8)\n","Requirement already satisfied: matplotlib in /usr/local/lib/python3.6/dist-packages (from geemap) (3.2.1)\n","Requirement already satisfied: google-api-python-client in /usr/local/lib/python3.6/dist-packages (from earthengine-api->geemap) (1.7.12)\n","Requirement already satisfied: google-auth>=1.4.1 in /usr/local/lib/python3.6/dist-packages (from earthengine-api->geemap) (1.7.2)\n","Requirement already satisfied: httplib2<1dev,>=0.9.2 in /usr/local/lib/python3.6/dist-packages (from earthengine-api->geemap) (0.17.3)\n","Requirement already satisfied: future in /usr/local/lib/python3.6/dist-packages (from earthengine-api->geemap) (0.16.0)\n","Requirement already satisfied: httplib2shim in /usr/local/lib/python3.6/dist-packages (from earthengine-api->geemap) (0.0.3)\n","Requirement already satisfied: six in /usr/local/lib/python3.6/dist-packages (from earthengine-api->geemap) (1.12.0)\n","Requirement already satisfied: google-cloud-storage in /usr/local/lib/python3.6/dist-packages (from earthengine-api->geemap) (1.18.1)\n","Requirement already satisfied: google-auth-httplib2>=0.0.3 in /usr/local/lib/python3.6/dist-packages (from earthengine-api->geemap) (0.0.3)\n","Requirement already satisfied: traittypes<3,>=0.2.1 in /usr/local/lib/python3.6/dist-packages (from ipyleaflet>=0.12.6->geemap) (0.2.1)\n","Collecting branca<0.4,>=0.3.1\n","  Downloading https://files.pythonhosted.org/packages/63/36/1c93318e9653f4e414a2e0c3b98fc898b4970e939afeedeee6075dd3b703/branca-0.3.1-py3-none-any.whl\n","Requirement already satisfied: ipywidgets<8,>=7.5.0 in /usr/local/lib/python3.6/dist-packages (from ipyleaflet>=0.12.6->geemap) (7.5.1)\n","Requirement already satisfied: traitlets>=4.3.0 in /usr/local/lib/python3.6/dist-packages (from bqplot->geemap) (4.3.3)\n","Requirement already satisfied: numpy>=1.10.4 in /usr/local/lib/python3.6/dist-packages (from bqplot->geemap) (1.18.4)\n","Requirement already satisfied: pandas in /usr/local/lib/python3.6/dist-packages (from bqplot->geemap) (1.0.3)\n","Requirement already satisfied: jinja2>=2.9 in /usr/local/lib/python3.6/dist-packages (from folium>=0.11.0->geemap) (2.11.2)\n","Requirement already satisfied: requests in /usr/local/lib/python3.6/dist-packages (from folium>=0.11.0->geemap) (2.23.0)\n","Requirement already satisfied: ratelim in /usr/local/lib/python3.6/dist-packages (from geocoder->geemap) (0.1.6)\n","Requirement already satisfied: logzero>=1.5.0 in /usr/local/lib/python3.6/dist-packages (from geeadd>=0.4.8->geemap) (1.5.0)\n","Requirement already satisfied: beautifulsoup4>=4.9.0 in /usr/local/lib/python3.6/dist-packages (from geeadd>=0.4.8->geemap) (4.9.0)\n","Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.6/dist-packages (from matplotlib->geemap) (0.10.0)\n","Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib->geemap) (2.4.7)\n","Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib->geemap) (1.2.0)\n","Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib->geemap) (2.8.1)\n","Requirement already satisfied: uritemplate<4dev,>=3.0.0 in /usr/local/lib/python3.6/dist-packages (from google-api-python-client->earthengine-api->geemap) (3.0.1)\n","Requirement already satisfied: cachetools<3.2,>=2.0.0 in /usr/local/lib/python3.6/dist-packages (from google-auth>=1.4.1->earthengine-api->geemap) (3.1.1)\n","Requirement already satisfied: rsa<4.1,>=3.1.4 in /usr/local/lib/python3.6/dist-packages (from google-auth>=1.4.1->earthengine-api->geemap) (4.0)\n","Requirement already satisfied: pyasn1-modules>=0.2.1 in /usr/local/lib/python3.6/dist-packages (from google-auth>=1.4.1->earthengine-api->geemap) (0.2.8)\n","Requirement already satisfied: setuptools>=40.3.0 in /usr/local/lib/python3.6/dist-packages (from google-auth>=1.4.1->earthengine-api->geemap) (46.1.3)\n","Requirement already satisfied: urllib3 in /usr/local/lib/python3.6/dist-packages (from httplib2shim->earthengine-api->geemap) (1.24.3)\n","Requirement already satisfied: certifi in /usr/local/lib/python3.6/dist-packages (from httplib2shim->earthengine-api->geemap) (2020.4.5.1)\n","Requirement already satisfied: google-resumable-media<0.5.0dev,>=0.3.1 in /usr/local/lib/python3.6/dist-packages (from google-cloud-storage->earthengine-api->geemap) (0.4.1)\n","Requirement already satisfied: google-cloud-core<2.0dev,>=1.0.0 in /usr/local/lib/python3.6/dist-packages (from google-cloud-storage->earthengine-api->geemap) (1.0.3)\n","Requirement already satisfied: ipykernel>=4.5.1 in /usr/local/lib/python3.6/dist-packages (from ipywidgets<8,>=7.5.0->ipyleaflet>=0.12.6->geemap) (4.10.1)\n","Requirement already satisfied: ipython>=4.0.0; python_version >= \"3.3\" in /usr/local/lib/python3.6/dist-packages (from ipywidgets<8,>=7.5.0->ipyleaflet>=0.12.6->geemap) (5.5.0)\n","Requirement already satisfied: nbformat>=4.2.0 in /usr/local/lib/python3.6/dist-packages (from ipywidgets<8,>=7.5.0->ipyleaflet>=0.12.6->geemap) (5.0.6)\n","Requirement already satisfied: widgetsnbextension~=3.5.0 in /usr/local/lib/python3.6/dist-packages (from ipywidgets<8,>=7.5.0->ipyleaflet>=0.12.6->geemap) (3.5.1)\n","Requirement already satisfied: decorator in /usr/local/lib/python3.6/dist-packages (from traitlets>=4.3.0->bqplot->geemap) (4.4.2)\n","Requirement already satisfied: ipython-genutils in /usr/local/lib/python3.6/dist-packages (from traitlets>=4.3.0->bqplot->geemap) (0.2.0)\n","Requirement already satisfied: pytz>=2017.2 in /usr/local/lib/python3.6/dist-packages (from pandas->bqplot->geemap) (2018.9)\n","Requirement already satisfied: MarkupSafe>=0.23 in /usr/local/lib/python3.6/dist-packages (from jinja2>=2.9->folium>=0.11.0->geemap) (1.1.1)\n","Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.6/dist-packages (from requests->folium>=0.11.0->geemap) (2.9)\n","Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.6/dist-packages (from requests->folium>=0.11.0->geemap) (3.0.4)\n","Requirement already satisfied: soupsieve>1.2 in /usr/local/lib/python3.6/dist-packages (from beautifulsoup4>=4.9.0->geeadd>=0.4.8->geemap) (2.0)\n","Requirement already satisfied: pyasn1>=0.1.3 in /usr/local/lib/python3.6/dist-packages (from rsa<4.1,>=3.1.4->google-auth>=1.4.1->earthengine-api->geemap) (0.4.8)\n","Requirement already satisfied: google-api-core<2.0.0dev,>=1.14.0 in /usr/local/lib/python3.6/dist-packages (from google-cloud-core<2.0dev,>=1.0.0->google-cloud-storage->earthengine-api->geemap) (1.16.0)\n","Requirement already satisfied: jupyter-client in /usr/local/lib/python3.6/dist-packages (from ipykernel>=4.5.1->ipywidgets<8,>=7.5.0->ipyleaflet>=0.12.6->geemap) (5.3.4)\n","Requirement already satisfied: tornado>=4.0 in /usr/local/lib/python3.6/dist-packages (from ipykernel>=4.5.1->ipywidgets<8,>=7.5.0->ipyleaflet>=0.12.6->geemap) (4.5.3)\n","Requirement already satisfied: pickleshare in /usr/local/lib/python3.6/dist-packages (from ipython>=4.0.0; python_version >= \"3.3\"->ipywidgets<8,>=7.5.0->ipyleaflet>=0.12.6->geemap) (0.7.5)\n","Requirement already satisfied: prompt-toolkit<2.0.0,>=1.0.4 in /usr/local/lib/python3.6/dist-packages (from ipython>=4.0.0; python_version >= \"3.3\"->ipywidgets<8,>=7.5.0->ipyleaflet>=0.12.6->geemap) (1.0.18)\n","Requirement already satisfied: simplegeneric>0.8 in /usr/local/lib/python3.6/dist-packages (from ipython>=4.0.0; python_version >= \"3.3\"->ipywidgets<8,>=7.5.0->ipyleaflet>=0.12.6->geemap) (0.8.1)\n","Requirement already satisfied: pexpect; sys_platform != \"win32\" in /usr/local/lib/python3.6/dist-packages (from ipython>=4.0.0; python_version >= \"3.3\"->ipywidgets<8,>=7.5.0->ipyleaflet>=0.12.6->geemap) (4.8.0)\n","Requirement already satisfied: pygments in /usr/local/lib/python3.6/dist-packages (from ipython>=4.0.0; python_version >= \"3.3\"->ipywidgets<8,>=7.5.0->ipyleaflet>=0.12.6->geemap) (2.1.3)\n","Requirement already satisfied: jsonschema!=2.5.0,>=2.4 in /usr/local/lib/python3.6/dist-packages (from nbformat>=4.2.0->ipywidgets<8,>=7.5.0->ipyleaflet>=0.12.6->geemap) (2.6.0)\n","Requirement already satisfied: jupyter-core in /usr/local/lib/python3.6/dist-packages (from nbformat>=4.2.0->ipywidgets<8,>=7.5.0->ipyleaflet>=0.12.6->geemap) (4.6.3)\n","Requirement already satisfied: notebook>=4.4.1 in /usr/local/lib/python3.6/dist-packages (from widgetsnbextension~=3.5.0->ipywidgets<8,>=7.5.0->ipyleaflet>=0.12.6->geemap) (5.2.2)\n","Requirement already satisfied: googleapis-common-protos<2.0dev,>=1.6.0 in /usr/local/lib/python3.6/dist-packages (from google-api-core<2.0.0dev,>=1.14.0->google-cloud-core<2.0dev,>=1.0.0->google-cloud-storage->earthengine-api->geemap) (1.51.0)\n","Requirement already satisfied: protobuf>=3.4.0 in /usr/local/lib/python3.6/dist-packages (from google-api-core<2.0.0dev,>=1.14.0->google-cloud-core<2.0dev,>=1.0.0->google-cloud-storage->earthengine-api->geemap) (3.10.0)\n","Requirement already satisfied: pyzmq>=13 in /usr/local/lib/python3.6/dist-packages (from jupyter-client->ipykernel>=4.5.1->ipywidgets<8,>=7.5.0->ipyleaflet>=0.12.6->geemap) (19.0.1)\n","Requirement already satisfied: wcwidth in /usr/local/lib/python3.6/dist-packages (from prompt-toolkit<2.0.0,>=1.0.4->ipython>=4.0.0; python_version >= \"3.3\"->ipywidgets<8,>=7.5.0->ipyleaflet>=0.12.6->geemap) (0.1.9)\n","Requirement already satisfied: ptyprocess>=0.5 in /usr/local/lib/python3.6/dist-packages (from pexpect; sys_platform != \"win32\"->ipython>=4.0.0; python_version >= \"3.3\"->ipywidgets<8,>=7.5.0->ipyleaflet>=0.12.6->geemap) (0.6.0)\n","Requirement already satisfied: nbconvert in /usr/local/lib/python3.6/dist-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets<8,>=7.5.0->ipyleaflet>=0.12.6->geemap) (5.6.1)\n","Requirement already satisfied: terminado>=0.3.3; sys_platform != \"win32\" in /usr/local/lib/python3.6/dist-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets<8,>=7.5.0->ipyleaflet>=0.12.6->geemap) (0.8.3)\n","Requirement already satisfied: pandocfilters>=1.4.1 in /usr/local/lib/python3.6/dist-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets<8,>=7.5.0->ipyleaflet>=0.12.6->geemap) (1.4.2)\n","Requirement already satisfied: bleach in /usr/local/lib/python3.6/dist-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets<8,>=7.5.0->ipyleaflet>=0.12.6->geemap) (3.1.5)\n","Requirement already satisfied: mistune<2,>=0.8.1 in /usr/local/lib/python3.6/dist-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets<8,>=7.5.0->ipyleaflet>=0.12.6->geemap) (0.8.4)\n","Requirement already satisfied: defusedxml in /usr/local/lib/python3.6/dist-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets<8,>=7.5.0->ipyleaflet>=0.12.6->geemap) (0.6.0)\n","Requirement already satisfied: entrypoints>=0.2.2 in /usr/local/lib/python3.6/dist-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets<8,>=7.5.0->ipyleaflet>=0.12.6->geemap) (0.3)\n","Requirement already satisfied: testpath in /usr/local/lib/python3.6/dist-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets<8,>=7.5.0->ipyleaflet>=0.12.6->geemap) (0.4.4)\n","Requirement already satisfied: packaging in /usr/local/lib/python3.6/dist-packages (from bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets<8,>=7.5.0->ipyleaflet>=0.12.6->geemap) (20.3)\n","Requirement already satisfied: webencodings in /usr/local/lib/python3.6/dist-packages (from bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets<8,>=7.5.0->ipyleaflet>=0.12.6->geemap) (0.5.1)\n","\u001b[31mERROR: datascience 0.10.6 has requirement folium==0.2.1, but you'll have folium 0.11.0 which is incompatible.\u001b[0m\n","Installing collected packages: branca\n","  Found existing installation: branca 0.4.1\n","    Uninstalling branca-0.4.1:\n","      Successfully uninstalled branca-0.4.1\n","Successfully installed branca-0.3.1\n"],"name":"stdout"},{"output_type":"display_data","data":{"application/vnd.colab-display-data+json":{"pip_warning":{"packages":["branca"]}}},"metadata":{"tags":[]}}]},{"cell_type":"code","metadata":{"id":"eTItiEBjTs1O","colab_type":"code","colab":{}},"source":["# memanggil library GeeMap\n","import geemap.eefolium as emap"],"execution_count":0,"outputs":[]},{"cell_type":"code","metadata":{"id":"afWtW4MCT7Sr","colab_type":"code","outputId":"a29e2a92-3451-4539-b680-57b781d36e31","executionInfo":{"status":"ok","timestamp":1589328674512,"user_tz":-420,"elapsed":1769,"user":{"displayName":"Dany Puguh Laksono","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gjd8eOzv4V9R3fnhZHMJEN542UAJIK5XPlKWPS5=s64","userId":"10973890960709691040"}},"colab":{"base_uri":"https://localhost:8080/","height":471,"referenced_widgets":["4361abed10bd46fabf9187a3924d4124","b8f7b18a4d4e41e597d1b946ad80f528"]}},"source":["# tutorial geemap\n","emap.show_youtube('h0pz3S6Tvx0')"],"execution_count":0,"outputs":[{"output_type":"display_data","data":{"application/vnd.jupyter.widget-view+json":{"model_id":"4361abed10bd46fabf9187a3924d4124","version_minor":0,"version_major":2},"text/plain":["Output(layout=Layout(width='815px'))"]},"metadata":{"tags":[]}}]},{"cell_type":"code","metadata":{"id":"iidv0YXMU57D","colab_type":"code","outputId":"0c189666-d4f4-4c2e-d732-b98060b5820e","executionInfo":{"status":"ok","timestamp":1589329177027,"user_tz":-420,"elapsed":818,"user":{"displayName":"Dany Puguh Laksono","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gjd8eOzv4V9R3fnhZHMJEN542UAJIK5XPlKWPS5=s64","userId":"10973890960709691040"}},"colab":{"base_uri":"https://localhost:8080/","height":583}},"source":["# inisiasi peta\n","Map = emap.Map(center=[-7.7681072,110.3771259], zoom=17)\n","\n","# memanggil peta\n","Map"],"execution_count":0,"outputs":[{"output_type":"execute_result","data":{"text/html":["<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><span style=\"color:#565656\">Make this Notebook Trusted to load map: File -> Trust Notebook</span><iframe src=\"about:blank\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" data-html=PCFET0NUWVBFIGh0bWw+CjxoZWFkPiAgICAKICAgIDxtZXRhIGh0dHAtZXF1aXY9ImNvbnRlbnQtdHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PVVURi04IiAvPgogICAgCiAgICAgICAgPHNjcmlwdD4KICAgICAgICAgICAgTF9OT19UT1VDSCA9IGZhbHNlOwogICAgICAgICAgICBMX0RJU0FCTEVfM0QgPSBmYWxzZTsKICAgICAgICA8L3NjcmlwdD4KICAgIAogICAgPHNjcmlwdCBzcmM9Imh0dHBzOi8vY2RuLmpzZGVsaXZyLm5ldC9ucG0vbGVhZmxldEAxLjYuMC9kaXN0L2xlYWZsZXQuanMiPjwvc2NyaXB0PgogICAgPHNjcmlwdCBzcmM9Imh0dHBzOi8vY29kZS5qcXVlcnkuY29tL2pxdWVyeS0xLjEyLjQubWluLmpzIj48L3NjcmlwdD4KICAgIDxzY3JpcHQgc3JjPSJodHRwczovL21heGNkbi5ib290c3RyYXBjZG4uY29tL2Jvb3RzdHJhcC8zLjIuMC9qcy9ib290c3RyYXAubWluLmpzIj48L3NjcmlwdD4KICAgIDxzY3JpcHQgc3JjPSJodHRwczovL2NkbmpzLmNsb3VkZmxhcmUuY29tL2FqYXgvbGlicy9MZWFmbGV0LmF3ZXNvbWUtbWFya2Vycy8yLjAuMi9sZWFmbGV0LmF3ZXNvbWUtbWFya2Vycy5qcyI+PC9zY3JpcHQ+CiAgICA8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Imh0dHBzOi8vY2RuLmpzZGVsaXZyLm5ldC9ucG0vbGVhZmxldEAxLjYuMC9kaXN0L2xlYWZsZXQuY3NzIi8+CiAgICA8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Imh0dHBzOi8vbWF4Y2RuLmJvb3RzdHJhcGNkbi5jb20vYm9vdHN0cmFwLzMuMi4wL2Nzcy9ib290c3RyYXAubWluLmNzcyIvPgogICAgPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJodHRwczovL21heGNkbi5ib290c3RyYXBjZG4uY29tL2Jvb3RzdHJhcC8zLjIuMC9jc3MvYm9vdHN0cmFwLXRoZW1lLm1pbi5jc3MiLz4KICAgIDxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iaHR0cHM6Ly9tYXhjZG4uYm9vdHN0cmFwY2RuLmNvbS9mb250LWF3ZXNvbWUvNC42LjMvY3NzL2ZvbnQtYXdlc29tZS5taW4uY3NzIi8+CiAgICA8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Imh0dHBzOi8vY2RuanMuY2xvdWRmbGFyZS5jb20vYWpheC9saWJzL0xlYWZsZXQuYXdlc29tZS1tYXJrZXJzLzIuMC4yL2xlYWZsZXQuYXdlc29tZS1tYXJrZXJzLmNzcyIvPgogICAgPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJodHRwczovL3Jhd2Nkbi5naXRoYWNrLmNvbS9weXRob24tdmlzdWFsaXphdGlvbi9mb2xpdW0vbWFzdGVyL2ZvbGl1bS90ZW1wbGF0ZXMvbGVhZmxldC5hd2Vzb21lLnJvdGF0ZS5jc3MiLz4KICAgIDxzdHlsZT5odG1sLCBib2R5IHt3aWR0aDogMTAwJTtoZWlnaHQ6IDEwMCU7bWFyZ2luOiAwO3BhZGRpbmc6IDA7fTwvc3R5bGU+CiAgICA8c3R5bGU+I21hcCB7cG9zaXRpb246YWJzb2x1dGU7dG9wOjA7Ym90dG9tOjA7cmlnaHQ6MDtsZWZ0OjA7fTwvc3R5bGU+CiAgICAKICAgICAgICAgICAgPG1ldGEgbmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9IndpZHRoPWRldmljZS13aWR0aCwKICAgICAgICAgICAgICAgIGluaXRpYWwtc2NhbGU9MS4wLCBtYXhpbXVtLXNjYWxlPTEuMCwgdXNlci1zY2FsYWJsZT1ubyIgLz4KICAgICAgICAgICAgPHN0eWxlPgogICAgICAgICAgICAgICAgI21hcF9iMWFjMDI2OTcwYmM0NTFiOTRjOTViNmE2NWNiZjIwMSB7CiAgICAgICAgICAgICAgICAgICAgcG9zaXRpb246IHJlbGF0aXZlOwogICAgICAgICAgICAgICAgICAgIHdpZHRoOiAxMDAuMCU7CiAgICAgICAgICAgICAgICAgICAgaGVpZ2h0OiAxMDAuMCU7CiAgICAgICAgICAgICAgICAgICAgbGVmdDogMC4wJTsKICAgICAgICAgICAgICAgICAgICB0b3A6IDAuMCU7CiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgIDwvc3R5bGU+CiAgICAgICAgCiAgICA8c2NyaXB0IHNyYz0iaHR0cHM6Ly9jZG5qcy5jbG91ZGZsYXJlLmNvbS9hamF4L2xpYnMvbGVhZmxldC5mdWxsc2NyZWVuLzEuNC4yL0NvbnRyb2wuRnVsbFNjcmVlbi5taW4uanMiPjwvc2NyaXB0PgogICAgPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJodHRwczovL2NkbmpzLmNsb3VkZmxhcmUuY29tL2FqYXgvbGlicy9sZWFmbGV0LmZ1bGxzY3JlZW4vMS40LjIvQ29udHJvbC5GdWxsU2NyZWVuLm1pbi5jc3MiLz4KPC9oZWFkPgo8Ym9keT4gICAgCiAgICAKICAgICAgICAgICAgPGRpdiBjbGFzcz0iZm9saXVtLW1hcCIgaWQ9Im1hcF9iMWFjMDI2OTcwYmM0NTFiOTRjOTViNmE2NWNiZjIwMSIgPjwvZGl2PgogICAgICAgIAo8L2JvZHk+CjxzY3JpcHQ+ICAgIAogICAgCiAgICAgICAgICAgIHZhciBtYXBfYjFhYzAyNjk3MGJjNDUxYjk0Yzk1YjZhNjVjYmYyMDEgPSBMLm1hcCgKICAgICAgICAgICAgICAgICJtYXBfYjFhYzAyNjk3MGJjNDUxYjk0Yzk1YjZhNjVjYmYyMDEiLAogICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgIGNlbnRlcjogWy03Ljc2ODEwNzIsIDExMC4zNzcxMjU5XSwKICAgICAgICAgICAgICAgICAgICBjcnM6IEwuQ1JTLkVQU0czODU3LAogICAgICAgICAgICAgICAgICAgIHpvb206IDE3LAogICAgICAgICAgICAgICAgICAgIHpvb21Db250cm9sOiB0cnVlLAogICAgICAgICAgICAgICAgICAgIHByZWZlckNhbnZhczogZmFsc2UsCiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICk7CgogICAgICAgICAgICAKCiAgICAgICAgCiAgICAKICAgICAgICAgICAgdmFyIHRpbGVfbGF5ZXJfMjQ4NzQ0NTA4YmJiNDY3YmEwNjk3MWMyMWE2NDczNGQgPSBMLnRpbGVMYXllcigKICAgICAgICAgICAgICAgICJodHRwczovL3tzfS50aWxlLm9wZW5zdHJlZXRtYXAub3JnL3t6fS97eH0ve3l9LnBuZyIsCiAgICAgICAgICAgICAgICB7ImF0dHJpYnV0aW9uIjogIkRhdGEgYnkgXHUwMDI2Y29weTsgXHUwMDNjYSBocmVmPVwiaHR0cDovL29wZW5zdHJlZXRtYXAub3JnXCJcdTAwM2VPcGVuU3RyZWV0TWFwXHUwMDNjL2FcdTAwM2UsIHVuZGVyIFx1MDAzY2EgaHJlZj1cImh0dHA6Ly93d3cub3BlbnN0cmVldG1hcC5vcmcvY29weXJpZ2h0XCJcdTAwM2VPRGJMXHUwMDNjL2FcdTAwM2UuIiwgImRldGVjdFJldGluYSI6IGZhbHNlLCAibWF4TmF0aXZlWm9vbSI6IDE4LCAibWF4Wm9vbSI6IDE4LCAibWluWm9vbSI6IDAsICJub1dyYXAiOiBmYWxzZSwgIm9wYWNpdHkiOiAxLCAic3ViZG9tYWlucyI6ICJhYmMiLCAidG1zIjogZmFsc2V9CiAgICAgICAgICAgICkuYWRkVG8obWFwX2IxYWMwMjY5NzBiYzQ1MWI5NGM5NWI2YTY1Y2JmMjAxKTsKICAgICAgICAKICAgIAogICAgICAgICAgICB2YXIgdGlsZV9sYXllcl80MDA1NDdiZTdmZGI0OGQ1OWUyYjdhOWVhYWE4Y2Y0MiA9IEwudGlsZUxheWVyKAogICAgICAgICAgICAgICAgImh0dHBzOi8vbXQxLmdvb2dsZS5jb20vdnQvbHlycz15XHUwMDI2eD17eH1cdTAwMjZ5PXt5fVx1MDAyNno9e3p9IiwKICAgICAgICAgICAgICAgIHsiYXR0cmlidXRpb24iOiAiR29vZ2xlIiwgImRldGVjdFJldGluYSI6IGZhbHNlLCAibWF4TmF0aXZlWm9vbSI6IDE4LCAibWF4Wm9vbSI6IDE4LCAibWluWm9vbSI6IDAsICJub1dyYXAiOiBmYWxzZSwgIm9wYWNpdHkiOiAxLCAic3ViZG9tYWlucyI6ICJhYmMiLCAidG1zIjogZmFsc2V9CiAgICAgICAgICAgICkuYWRkVG8obWFwX2IxYWMwMjY5NzBiYzQ1MWI5NGM5NWI2YTY1Y2JmMjAxKTsKICAgICAgICAKICAgIAogICAgICAgICAgICAgICAgdmFyIGxhdF9sbmdfcG9wdXBfMDg0MGQxZGUyMWI1NGY1OGIyMDc5YmNlN2VmNDUwOGEgPSBMLnBvcHVwKCk7CiAgICAgICAgICAgICAgICBmdW5jdGlvbiBsYXRMbmdQb3AoZSkgewogICAgICAgICAgICAgICAgICAgIGxhdF9sbmdfcG9wdXBfMDg0MGQxZGUyMWI1NGY1OGIyMDc5YmNlN2VmNDUwOGEKICAgICAgICAgICAgICAgICAgICAgICAgLnNldExhdExuZyhlLmxhdGxuZykKICAgICAgICAgICAgICAgICAgICAgICAgLnNldENvbnRlbnQoIkxhdGl0dWRlOiAiICsgZS5sYXRsbmcubGF0LnRvRml4ZWQoNCkgKwogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiPGJyPkxvbmdpdHVkZTogIiArIGUubGF0bG5nLmxuZy50b0ZpeGVkKDQpKQogICAgICAgICAgICAgICAgICAgICAgICAub3Blbk9uKG1hcF9iMWFjMDI2OTcwYmM0NTFiOTRjOTViNmE2NWNiZjIwMSk7CiAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgbWFwX2IxYWMwMjY5NzBiYzQ1MWI5NGM5NWI2YTY1Y2JmMjAxLm9uKCdjbGljaycsIGxhdExuZ1BvcCk7CiAgICAgICAgICAgIAogICAgCiAgICAgICAgICAgIEwuY29udHJvbC5mdWxsc2NyZWVuKAogICAgICAgICAgICAgICAgeyJmb3JjZVNlcGFyYXRlQnV0dG9uIjogZmFsc2UsICJwb3NpdGlvbiI6ICJ0b3BsZWZ0IiwgInRpdGxlIjogIkZ1bGwgU2NyZWVuIiwgInRpdGxlQ2FuY2VsIjogIkV4aXQgRnVsbCBTY3JlZW4ifQogICAgICAgICAgICApLmFkZFRvKG1hcF9iMWFjMDI2OTcwYmM0NTFiOTRjOTViNmE2NWNiZjIwMSk7CiAgICAgICAgCiAgICAKICAgICAgICAgICAgbWFwX2IxYWMwMjY5NzBiYzQ1MWI5NGM5NWI2YTY1Y2JmMjAxLmZpdEJvdW5kcygKICAgICAgICAgICAgICAgIFtbLTcuNzY4MTA3MiwgMTEwLjM3NzEyNTldLCBbLTcuNzY4MTA3MiwgMTEwLjM3NzEyNTldXSwKICAgICAgICAgICAgICAgIHsibWF4Wm9vbSI6IDE3fQogICAgICAgICAgICApOwogICAgICAgIAo8L3NjcmlwdD4= onload=\"this.contentDocument.open();this.contentDocument.write(atob(this.getAttribute('data-html')));this.contentDocument.close();\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"],"text/plain":["<geemap.eefolium.Map at 0x7f2d34db60f0>"]},"metadata":{"tags":[]},"execution_count":42}]},{"cell_type":"markdown","metadata":{"id":"5xpJ7w2AYOoc","colab_type":"text"},"source":["### Menggunakan GEEMap\n"]},{"cell_type":"code","metadata":{"id":"FvVa9htQU_-a","colab_type":"code","outputId":"a4adb7b0-c1a3-476e-d9a0-fa446be639df","executionInfo":{"status":"ok","timestamp":1589329239738,"user_tz":-420,"elapsed":1457,"user":{"displayName":"Dany Puguh Laksono","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gjd8eOzv4V9R3fnhZHMJEN542UAJIK5XPlKWPS5=s64","userId":"10973890960709691040"}},"colab":{"base_uri":"https://localhost:8080/","height":34}},"source":["Map = emap.Map(center=[-7.7681072,110.3771259], zoom=17)\n","# Add Earth Engine dataset\n","dem = ee.Image('USGS/SRTMGL1_003')\n","\n","# Set visualization parameters.\n","vis_params = {\n","  'min': 0,\n","  'max': 4000,\n","  'palette': ['006633', 'E5FFCC', '662A00', 'D8D8D8', 'F5F5F5']}\n","\n","# Print the elevation of Mount Everest.\n","xy = ee.Geometry.Point([110.4369693, -7.540696])\n","elev = dem.sample(xy, 30).first().get('elevation').getInfo()\n","print('Mount Merapi elevation (m):', elev)\n","\n","# Add Earth Engine layers to Map\n","Map.addLayer(dem, vis_params, 'SRTM DEM', True, 0.5)\n","Map.addLayer(xy, {'color': 'red'}, 'Mount Everest')\n","\n","# Center the map based on an Earth Eninge object or coordinates (longitude, latitude)\n","# Map.centerObject(xy, 4)\n","Map.setCenter(110.3771259, -7.7681072,  9)"],"execution_count":0,"outputs":[{"output_type":"stream","text":["Mount Merapi elevation (m): 2232\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"id":"NYT-8j6KYTUZ","colab_type":"code","colab":{}},"source":["# menambahkan basemap\n","Map.add_basemap('Esri Ocean')\n","Map.add_basemap('Esri Physical Map')\n","Map.add_basemap('Esri National Geographic')\n"],"execution_count":0,"outputs":[]},{"cell_type":"code","metadata":{"id":"ysl3GJebZLCv","colab_type":"code","outputId":"3df4fc21-f000-4be9-ab30-85c55b8acc7a","executionInfo":{"status":"ok","timestamp":1589329246700,"user_tz":-420,"elapsed":918,"user":{"displayName":"Dany Puguh Laksono","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gjd8eOzv4V9R3fnhZHMJEN542UAJIK5XPlKWPS5=s64","userId":"10973890960709691040"}},"colab":{"base_uri":"https://localhost:8080/","height":583}},"source":["# Menampilkan peta\n","Map.addLayerControl()\n","Map"],"execution_count":0,"outputs":[{"output_type":"execute_result","data":{"text/html":["<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><span style=\"color:#565656\">Make this Notebook Trusted to load map: File -> Trust Notebook</span><iframe src=\"about:blank\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" data-html=<!DOCTYPE html>
<head>    
    <meta http-equiv="content-type" content="text/html; charset=UTF-8" />
    
        <script>
            L_NO_TOUCH = false;
            L_DISABLE_3D = false;
        </script>
    
    <script src="https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.js"></script>
    <script src="https://code.jquery.com/jquery-1.12.4.min.js"></script>
    <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/js/bootstrap.min.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.js"></script>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.css"/>
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css"/>
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap-theme.min.css"/>
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.6.3/css/font-awesome.min.css"/>
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.css"/>
    <link rel="stylesheet" href="https://rawcdn.githack.com/python-visualization/folium/master/folium/templates/leaflet.awesome.rotate.css"/>
    <style>html, body {width: 100%;height: 100%;margin: 0;padding: 0;}</style>
    <style>#map {position:absolute;top:0;bottom:0;right:0;left:0;}</style>
    
            <meta name="viewport" content="width=device-width,
                initial-scale=1.0, maximum-scale=1.0, user-scalable=no" />
            <style>
                #map_dc57f77025f8400994e62739f5c78b16 {
                    position: relative;
                    width: 100.0%;
                    height: 100.0%;
                    left: 0.0%;
                    top: 0.0%;
                }
            </style>
        
    <script src="https://cdnjs.cloudflare.com/ajax/libs/leaflet.fullscreen/1.4.2/Control.FullScreen.min.js"></script>
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/leaflet.fullscreen/1.4.2/Control.FullScreen.min.css"/>
</head>
<body>    
    
            <div class="folium-map" id="map_dc57f77025f8400994e62739f5c78b16" ></div>
        
</body>
<script>    
    
            var map_dc57f77025f8400994e62739f5c78b16 = L.map(
                "map_dc57f77025f8400994e62739f5c78b16",
                {
                    center: [-7.7681072, 110.3771259],
                    crs: L.CRS.EPSG3857,
                    zoom: 17,
                    zoomControl: true,
                    preferCanvas: false,
                }
            );

            

        
    
            var tile_layer_5d2820988cb94b90841bd38b46850a73 = L.tileLayer(
                "https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png",
                {"attribution": "Data by \u0026copy; \u003ca href=\"http://openstreetmap.org\"\u003eOpenStreetMap\u003c/a\u003e, under \u003ca href=\"http://www.openstreetmap.org/copyright\"\u003eODbL\u003c/a\u003e.", "detectRetina": false, "maxNativeZoom": 18, "maxZoom": 18, "minZoom": 0, "noWrap": false, "opacity": 1, "subdomains": "abc", "tms": false}
            ).addTo(map_dc57f77025f8400994e62739f5c78b16);
        
    
            var tile_layer_400547be7fdb48d59e2b7a9eaaa8cf42 = L.tileLayer(
                "https://mt1.google.com/vt/lyrs=y\u0026x={x}\u0026y={y}\u0026z={z}",
                {"attribution": "Google", "detectRetina": false, "maxNativeZoom": 18, "maxZoom": 18, "minZoom": 0, "noWrap": false, "opacity": 1, "subdomains": "abc", "tms": false}
            ).addTo(map_dc57f77025f8400994e62739f5c78b16);
        
    
                var lat_lng_popup_9b7f01ea9dbd44a3849a32d66ab19aa4 = L.popup();
                function latLngPop(e) {
                    lat_lng_popup_9b7f01ea9dbd44a3849a32d66ab19aa4
                        .setLatLng(e.latlng)
                        .setContent("Latitude: " + e.latlng.lat.toFixed(4) +
                                    "<br>Longitude: " + e.latlng.lng.toFixed(4))
                        .openOn(map_dc57f77025f8400994e62739f5c78b16);
                    }
                map_dc57f77025f8400994e62739f5c78b16.on('click', latLngPop);
            
    
            L.control.fullscreen(
                {"forceSeparateButton": false, "position": "topleft", "title": "Full Screen", "titleCancel": "Exit Full Screen"}
            ).addTo(map_dc57f77025f8400994e62739f5c78b16);
        
    
            map_dc57f77025f8400994e62739f5c78b16.fitBounds(
                [[-7.7681072, 110.3771259], [-7.7681072, 110.3771259]],
                {"maxZoom": 17}
            );
        
    
            var tile_layer_676e9ed54019473aa6cb76034ac04540 = L.tileLayer(
                "https://earthengine.googleapis.com/v1alpha/projects/earthengine-legacy/maps/e772f0b6ccf89aae965d25d9887de682-87e78bd40694dcb6b151c4403ee1d439/tiles/{z}/{x}/{y}",
                {"attribution": "Google Earth Engine", "detectRetina": false, "maxNativeZoom": 18, "maxZoom": 18, "minZoom": 0, "noWrap": false, "opacity": 0.5, "subdomains": "abc", "tms": false}
            ).addTo(map_dc57f77025f8400994e62739f5c78b16);
        
    
            var tile_layer_108e63f077bd41e6ae501d3060d10d97 = L.tileLayer(
                "https://earthengine.googleapis.com/v1alpha/projects/earthengine-legacy/maps/00df6654112802aa47c60c4a3fd9ce85-d8a78a17d385e5c8f726bf616e8adaa1/tiles/{z}/{x}/{y}",
                {"attribution": "Google Earth Engine", "detectRetina": false, "maxNativeZoom": 18, "maxZoom": 18, "minZoom": 0, "noWrap": false, "opacity": 1.0, "subdomains": "abc", "tms": false}
            ).addTo(map_dc57f77025f8400994e62739f5c78b16);
        
    
            map_dc57f77025f8400994e62739f5c78b16.fitBounds(
                [[-7.7681072, 110.3771259], [-7.7681072, 110.3771259]],
                {"maxZoom": 9}
            );
        
    
            var tile_layer_e8944a9d741b4ff8997f0f808f67514f = L.tileLayer(
                "https://services.arcgisonline.com/ArcGIS/rest/services/Ocean/World_Ocean_Base/MapServer/tile/{z}/{y}/{x}",
                {"attribution": "Esri", "detectRetina": false, "maxNativeZoom": 18, "maxZoom": 18, "minZoom": 0, "noWrap": false, "opacity": 1, "subdomains": "abc", "tms": false}
            ).addTo(map_dc57f77025f8400994e62739f5c78b16);
        
    
            var tile_layer_19503dbe71244714ab4ef59a691bab1d = L.tileLayer(
                "https://services.arcgisonline.com/arcgis/rest/services/World_Physical_Map/MapServer/tile/{z}/{y}/{x}",
                {"attribution": "Esri", "detectRetina": false, "maxNativeZoom": 18, "maxZoom": 18, "minZoom": 0, "noWrap": false, "opacity": 1, "subdomains": "abc", "tms": false}
            ).addTo(map_dc57f77025f8400994e62739f5c78b16);
        
    
            var tile_layer_d7352a0e1d674c80a548d2bab9a4ef0a = L.tileLayer(
                "http://services.arcgisonline.com/ArcGIS/rest/services/NatGeo_World_Map/MapServer/tile/{z}/{y}/{x}",
                {"attribution": "Esri", "detectRetina": false, "maxNativeZoom": 18, "maxZoom": 18, "minZoom": 0, "noWrap": false, "opacity": 1, "subdomains": "abc", "tms": false}
            ).addTo(map_dc57f77025f8400994e62739f5c78b16);
        
    
            var layer_control_71259e144ee54388be8a28209d755fc2 = {
                base_layers : {
                    "openstreetmap" : tile_layer_5d2820988cb94b90841bd38b46850a73,
                },
                overlays :  {
                    "Google Satellite" : tile_layer_400547be7fdb48d59e2b7a9eaaa8cf42,
                    "SRTM DEM" : tile_layer_676e9ed54019473aa6cb76034ac04540,
                    "Mount Everest" : tile_layer_108e63f077bd41e6ae501d3060d10d97,
                    "Esri Ocean" : tile_layer_e8944a9d741b4ff8997f0f808f67514f,
                    "Esri Physical Map" : tile_layer_19503dbe71244714ab4ef59a691bab1d,
                    "Esri National Geographic" : tile_layer_d7352a0e1d674c80a548d2bab9a4ef0a,
                },
            };
            L.control.layers(
                layer_control_71259e144ee54388be8a28209d755fc2.base_layers,
                layer_control_71259e144ee54388be8a28209d755fc2.overlays,
                {"autoZIndex": true, "collapsed": true, "position": "topright"}
            ).addTo(map_dc57f77025f8400994e62739f5c78b16);
        
</script> onload=\"this.contentDocument.open();this.contentDocument.write(atob(this.getAttribute('data-html')));this.contentDocument.close();\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"],"text/plain":["<geemap.eefolium.Map at 0x7f2d34d6ee48>"]},"metadata":{"tags":[]},"execution_count":50}]},{"cell_type":"markdown","metadata":{"id":"K7WydzKocW0o","colab_type":"text"},"source":["\n","---\n","# Google Earth Engine pada QGIS\n","\n","Dengan memanfaatkan Python API, maka pengguna QGIS juga dapat menggunakan Google Earth Engine pada jendela QGIS mereka.\n","\n","Untuk keperluan ini, dapat digunakan plugin di QGIS, yaitu https://gee-community.github.io/qgis-earthengine-plugin/\n","\n","Untuk menggunakan Earth Engine di QGIS, langkahnya adalah sebagai berikut:\n","1. Install plugin Google Earth Engine pada Plugin Manager QGIS\n","2. Ikuti Langkah yang diberikan untuk melakukan autentikasi akun\n","3. Setelah akun terverivikasi, GEE sudah dapat digunakan dengan memanfaatkan Python Console di QGIS\n","\n","![alt text](https://drive.google.com/uc?id=1tXqvgoHm3g3z5eM8aSMqNses7d2gd8LH)\n"]},{"cell_type":"code","metadata":{"id":"27U9gSRtGpKJ","colab_type":"code","colab":{}},"source":["# Contoh script untuk memanggil GEE pada QGIS\n","# copy paste pada Python Editor di QGIS\n","import ee\n","from ee_plugin import Map\n","\n","collection = ee.ImageCollection('LANDSAT/LC08/C01/T1')\n","\n","point = ee.Geometry.Point(119.4280, -5.13269)\n","start = ee.Date('2017-06-01')\n","finish = ee.Date('2017-12-01')\n","\n","filteredCollection = ee.ImageCollection('LANDSAT/LC08/C01/T1') \\\n","    .filterBounds(point) \\\n","    .filterDate(start, finish) \\\n","    .sort('CLOUD_COVER', True)\n","\n","first = filteredCollection.first()\n","# Define visualization parameters in an object literal.\n","vizParams = {'bands': ['B5', 'B4', 'B3'],\n","             'min': 5000, 'max': 15000, 'gamma': 1.3}\n","Map.addLayer(first, vizParams, 'Landsat 8 image')\n"],"execution_count":0,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"LwW81fQXqQzZ","colab_type":"text"},"source":["---\n","# Rujukan\n","\n","Berikut adalah beberapa rujukan terkait dengan penggunaan GEE di Google Colab dan QGIS:\n","- https://colab.research.google.com/github/csaybar/EEwPython/blob/master/index.ipynb\n","- https://github.com/giswqs/qgis-earthengine-examples/\n","- https://github.com/giswqs/earthengine-py-notebooks\n","- https://github.com/giswqs/geemap\n","- https://github.com/csaybar/EEwPython\n","- https://twitter.com/giswqs\n","- https://twitter.com/EarthEngineBot\n","- https://twitter.com/gena_d\n","\n","\n","\n"]},{"cell_type":"code","metadata":{"id":"ZtoOSI9LTVeW","colab_type":"code","colab":{}},"source":[""],"execution_count":0,"outputs":[]}]}