Forem: Tek Kshetri

How to calculate land use area change over time in GEE?

Tek Kshetri — Wed, 08 Jan 2025 17:31:35 +0000

In this article, I am going to write about how to generate land use area changes over time using Google Earth Engine (GEE).

VIDEO TUTORIAL || FULL CODE

1. Input Dataset

For this example, I am going to use the Landsat Imagery. I am going to use Landsat 4-9.

2. Preprocess Imagery

Pre-processing imagery steps include selecting the appropriate image (cloud-free images), and mosaic and taking a mean or median value, clip image to an area of interest.

3. Calculate Area

The next step is to iterate over each year from 1984 to calculate the area of the appropriate area pixel. If no image was suitable in particular imagery, remove that from the analysis and replace the value with nan.

4. Generate Graph

In the final step, we can easily generate the graph using the ui.Chart module. The final output graph will look something like below,

Generate files and folder structures of your code

Tek Kshetri — Fri, 23 Jun 2023 04:02:27 +0000

I recently found a cool way to generate the file and folder structure inside your root project directory. In order to generate the folder structure, you need to follow following steps,

1. Download `tree` package

If you are in mac, type following code in your terminal,

brew install tree

If you are in ubuntu, type following code in your terminal,

sudo apt install tree

2. Navigate to the root directory

cd ~/Downloads/my-project

Make sure to change the path.

3. Explore tree command

If you want to generate the files and folder structure in your working directory, just type tree command in terminal and it will print out the files and folders in proper structure,

tree

But, most of the time, our project might contain some of the unnecessary things such as, node_modules, python_venv etc. In that case, you might want to avoid those folders or files. In order to avoid those, simply wright the following code,

find . -type f -not -path '*/\.*' | grep -v -F -f .gitignore | cut -c 3- | tree --fromfile --prune

Let me explain the code for you,

find . -type f -not -path '*/\.*': This command recursively finds all the files (-type f) in the current directory (.) and its subdirectories. The -not -path '*/\.*' part excludes hidden files such as .git.
grep -v -F -f .gitignore: This command filters out the files and directories listed in the .gitignore file.
The cut -c 3- command removes the first two characters from each line of input, effectively removing the "./" prefix in each path.
tree --fromfile --prune: This command reads the file and directory structure from the output of the previous commands and displays it using the tree command. The --prune option excludes the empty directories from the output.

I got the following result from above script:

.
├── __init__.py
├── file1.ipynb
├── file2.ipynb
├── requirements.txt
├── script_json
│   ├── test1.json
│   └── test2.json
├── version1.ipynb
└── version2.ipynb

I hope this post is informative for you. If you like this blog, please support me by subscribing to my YouTube channel: https://www.youtube.com/c/iamtekson

Generate and Add a new SSH key to your GitHub account

Tek Kshetri — Wed, 13 Jul 2022 09:35:54 +0000

When working with a GitHub repository, you'll often need to identify yourself to GitHub using your username and password. An SSH key is an alternate way to identify yourself that doesn't require you to enter you username and password every time. To add such key, you need to generate it on your PC. To generate and add it to GitHub, you need to follow following steps,

1. Generate the SSH key

The SSH key can be generated using ssh-keygen command using git bash as below,

ssh-keygen -t ed25519 -C "your_email@example.com"

replace your_email@example.com with your actual email address.

2. Add your SSH key to GitHub

By default, the SSH key will be stored in the home directory. Now, you need to copy the public key. The public key can be seen using cat command as below,

cat ~/.ssh/id_rsa.pub

Copy the public key from terminal. The final step is to add it to the GitHub.

To add it, go to your GitHub profile settings > SSH and GPG keys > new SSH key, add title for your key and paste the public key in Key box.

I hope this post is informative for you. If you like this blog, please support me by subscribing to my YouTube channel: https://www.youtube.com/c/iamtekson

Write and Publish Python Code Documentation Automatically

Tek Kshetri — Mon, 11 Jul 2022 09:10:31 +0000

We all know that programmers write code but many of us are not aware that they read more than write. The clean code will be easier to read. In this article, I am going to explain about the process of writing and publishing the python code documentation easy and effective way. Below is the table of content,

1. Write the standard docstring
2. Install Sphinx
3. Initialize Sphinx
4. Update the conf.py file
5. Auto generate the rst file
6. Build HTML
7. Publish the documentation online
8. Reference

1. Write the standard docstring

Good programmers prefer to write the logic behind each class, methods, function etc using comments. In python, the best way to add the comments for the functions or class is to write in docstring format. Later, it can be used by documentation automation tools like sphnix to generate the document. But for the automation, you should follow the standard docstring guideline. Here is the small example of good docstring example,



def add(x, y):
    """Function to add two numbers 

        Parameters
        ----------
        x: int
            First number to add
        y: int
            Second number to add

        Returns
        -------
        int
            The sum of x and y
        """
    return x + y

2. Install sphinx

Now next step is to install the sphnix. It can be installed easily using pip command,



pip install sphinx

3. Initialize the sphinx

In the root directory of your project, run sphinx-quickstart to initialize the sphinx source directory to create a default configuration. I prefer to have separated directory for build and source, I hope you will also do the same.



sphinx-quickstart

Below image is the example of my sphinx-quickstart,

As shown above, running the sphinx-build command creates a Makefile, a make.bat file, as well as build and source directories.

4. Update the `conf.py` file

The conf.py file is inside the source folder which describes the sphinx configurations to control the documentation. Here, I recommend you to overwrite the following things,

Add project information

In the project information section, you need to update about copyright, author, release etc. Following is the example of my project information,



# -- Project information -----------------------------------------------------

project = 'GeoTile'
copyright = '2022, Tek Kshetri'
author = 'Tek Kshetri'

# The full version, including alpha/beta/rc tags
release = '0.1.0'

Add extensions

By default, there will be no extension added to the documentation. You have to add at least following extension to generate the documentation



extensions = [
   'sphinx.ext.doctest',
   'sphinx.ext.autodoc',
   'sphinx.ext.autosummary',
   'sphinx.ext.napoleon',
]

Update theme

The default theme for sphinx is alabaster. There are several other themes are available, but personally, I like pydata_sphinx_theme. To change the theme, you need to install it first using terminal,



pip install pydata_sphinx_theme

And update it to the conf.py file,



# html theme for documentation
html_theme = "pydata_sphinx_theme"

There are several ways to customize this theme. If you are interested, please check the official documentation of pydata_sphinx_theme

Specify the location of the python modules

At the top of the conf.py file, you will see some commented line of code. If your python code path is outside the documentation directory (Most of the case is like this), you have to specify the path to the code like below,



import os
import sys
sys.path.insert(0, os.path.abspath('../..'))

Here is my folder structure,

5. Auto generate the `rst` file

Sphinx generates the HTML documentation from reStructuredText (rst) files. To autogenerate the rst files, run the sphinx-apidoc command using following syntax:



sphinx-apidoc -o <OUTPUT_PATH> <MODULE_PATH>

In my case, the output directory is source, and the module directory is testCode. I have to run following command from documentation root folder,



sphinx-apidoc -f -o source ../testCode

The above command will create at least two files, modules.rst and test.rst. You can open it with any text editor and see the configuration or manually edit the things as well.

6. Build HTML

Before building the HTML document, we need to insert the modules.rst file to source/index.rst file toctree. Please add the API reference <modules> to toctree as below,



.. toctree::
   :maxdepth: 2
   :caption: Test Documentation

   API reference <modules>

After that run the following command from your documentation root directory,



make html

This command will generate the html file inside the build directory. You can open it with any browser to check the documentation.

7. Publish the documentation online

To publish the documentation, I am going to use Read the Docs open-source solution. Using read the docs, you can publish your documentation free of cost. Here is the guideline for publishing,

Create account

If you don't have read the docs account, create account and login to the read the docs site.

Import project

In your user dashboard, there is option to Import a Project. Click the option, again click on Import Manually button. Add the project name, repository URL (GitHub url to your documentation), and default branch and click next.

Again add the extra details about your project.

The final step is to build the version and view the docs,

If you did everything correctly, live version of your documentation will be rendered after clicking view docs button.

I hope this blog post is informative for you. If you like this blog, please support me by subscribing to my YouTube channel: https://www.youtube.com/c/iamtekson

8. Reference

Upload large file to GitHub

Tek Kshetri — Fri, 08 Jul 2022 02:32:59 +0000

To upload large file to GitHub, follow the following steps,

1. Install and select LFS file

git lfs install

# I am adding the deep learning model file
git lfs track "*.h5"

2. Commit and push to the GitHub

git lfs push --all origin main

git add .
git commit -am "add large file"
git push -u origin main

Solve large file upload issue

If you already tried to upload the file and facing remote: error: File model.h5 is 270.75 MB; this exceeds GitHub's file size limit of 100.00 MB similar issue, It can be solved by following method,

1. Reset `git`

git reset HEAD~<HOWEVER MANY COMMITS YOU WERE BEHIND>

If you want to go before one commit: git reset HEAD~1

Pro Tip: Check git log: git log

2. Check status and push

git status

git push

Release Conda package from PyPI

Tek Kshetri — Fri, 01 Jul 2022 02:46:42 +0000

To add the PyPI package to conda distribution (conda-forge), you need to follow the following method,

1. Fork the staged-recipes repository

2. Create configuration files

After creating the fork in your GitHub, first step is to clone your fork,

git clone https://github.com/iamtekson/staged-recipes.git

Please replace the git clone URL.

Now, add the LICENSE and meta.yaml file inside recipes/yourPackageName folder.

Below is the example of MIT license file,

MIT License

Copyright (c) 2020, Tek Kshetri

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

Inside meta.yaml file, you need to write your package configuration. The easiest way is to copy the file from example > meta.yaml file and edit it. Here is the example of geoserver-rest package,

{% set name = 'geoserver-rest' %}
{% set version = '0.1.0' %}
package:
  name: {{ name|lower }}
  version: {{ version }}

source:
  url: https://pypi.io/packages/source/{{ name[0] }}/{{ name }}/{{ name }}-{{ version }}.tar.gz
  sha256: 625327b23ee2ee77e839272b04d0b6e81b7dc98e0713e4e23d003a1bf2461551

build:
  noarch: python
  number: 0
  script: "{{ PYTHON }} -m pip install . -vv"

requirements:
  host:
    - python >=3.6
    - pip

  run:
    - python >=3.6
    - pip
    - gdal
    - seaborn
    - pycurl
    - psycopg2

test:
  imports:
    - geo
  commands:
    - pip check
  requires:
    - pip

about:
  home: https://github.com/gicait/geoserver-rest
  license: MIT
  license_file: LICENSE
  summary: "The package for management of geospatial data in GeoServer."
  description: |
    The geoserver-rest package is useful for the management for geospatial data in GeoServer. The package is useful for the creating, updating and deleting geoserver workspaces, stores, layers, and style files.
  dev_url: https://github.com/gicait/geoserver-rest

extra:
  recipe-maintainers:
    - iamtekson

3. Submit the pull request

This is the final step. Now you have to create the new branch, push code to your fork and submit the pull request. Below is the code for creating new branch and push code,

git branch myPackageName
git checkout myPackageName

git add .
git commit -m "added myPackageName to conda-forge"
git push --set-upstream origin myPackageName

Now, check your GitHub account and submit the pull request. After submitting the pull request, some of the test functions (GitHub actions) will automatically run and you will notify if there is any mistake.

If your pull request merged, that means your package can be install using conda distribution as well. You can check the package availability by using conda installation as below,

conda install -c conda-forge myPackageName

Check this pull request for your reference: https://github.com/conda-forge/staged-recipes/pull/14143

Congratulations! you finally managed to publish your package to conda distribution. If you like this blog, please support me by subscribing to my YouTube channel: https://www.youtube.com/c/iamtekson

Publish Package to PyPI and Release Version Automation Using GitHub Actions

Tek Kshetri — Thu, 30 Jun 2022 09:05:59 +0000

Manually creating tags, publishing the package and creating the GitHub release is time consuming repetitive task. Creating the version means, same version should be used to create the release and also to publish the package to PyPI library. In this article, I am going to automate this process. Please follow the following steps to automate such task,

1. Create the API token from PyPI

The API token can be created from PyPI user account setting. After creating the token, it will be listed out in the API key section.

2. Add API key to the GitHub secret

Now, you need to add the same to the GitHub repository secret. To add that, you need to go to the repository setting, then click on Secrets > actions > New repository secret. Add the name of the secret as PYPI_API_TOKEN.

3. Add the YML file to GitHub Workflow

In the repository, create .github/workflows/release_to_pypi.yml file. In this file, you need to write the configuration code for publishing your package. Write the following code into release file to get start,

name: Publish ${package_name} to PyPI / GitHub

on:
  push:
    tags:
      - "v*"

The first name key denotes the name of the task. The second chunk, on key denotes on which condition this condition should run. In above case, whenever the tag starting with letter v is pushed into GitHub, this action will run.

Now add the jobs for this action,

jobs:
  build-n-publish:
    name: Build and publish to PyPI
    runs-on: ubuntu-latest

    steps:
      - name: Checkout source
        uses: actions/checkout@v2

      - name: Set up Python
        uses: actions/setup-python@v2
        with:
          python-version: "3.x"

      - name: Build source and wheel distributions
        run: |
          python -m pip install --upgrade build twine
          python -m build
          twine check --strict dist/*
      - name: Publish distribution to PyPI
        uses: pypa/gh-action-pypi-publish@master
        with:
          user: __token__
          password: ${{ secrets.PYPI_API_TOKEN }}

      - name: Create GitHub Release
        id: create_release
        uses: actions/create-release@v1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # This token is provided by Actions, you do not need to create your own token
        with:
          tag_name: ${{ github.ref }}
          release_name: ${{ github.ref }}
          draft: false
          prerelease: false

      - name: Get Asset name
        run: |
          export PKG=$(ls dist/ | grep tar)
          set -- $PKG
          echo "name=$1" >> $GITHUB_ENV
      - name: Upload Release Asset (sdist) to GitHub
        id: upload-release-asset
        uses: actions/upload-release-asset@v1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          upload_url: ${{ steps.create_release.outputs.upload_url }}
          asset_path: dist/${{ env.name }}
          asset_name: ${{ env.name }}
          asset_content_type: application/zip

These all things are the default things for publishing the package to the PyPI library and to release the GitHub version. You simply copy and paste this code to release_to_pypi.yml library.

I only want to address two things here, the first one is, in the password key(password: ${{ secrets.PYPI_API_TOKEN }}), the secrets we created in previous step is going to use. Make sure the name of the secret creating in the GitHub repository matched to the name of the above variable. Another things is, the GITHUB_TOKEN key (GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}), this secret is provided by GitHub actions, you don't need to create your own token.

If you only want to publish package to PyPI (Do not want to release in GitHub, feel free to remove the last two section from above code, i.e.,

 - name: Create GitHub Release
        id: create_release
        uses: actions/create-release@v1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # This token is provided by Actions, you do not need to create your own token
        with:
          tag_name: ${{ github.ref }}
          release_name: ${{ github.ref }}
          draft: false
          prerelease: false

      - name: Get Asset name
        run: |
          export PKG=$(ls dist/ | grep tar)
          set -- $PKG
          echo "name=$1" >> $GITHUB_ENV
      - name: Upload Release Asset (sdist) to GitHub
        id: upload-release-asset
        uses: actions/upload-release-asset@v1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          upload_url: ${{ steps.create_release.outputs.upload_url }}
          asset_path: dist/${{ env.name }}
          asset_name: ${{ env.name }}
          asset_content_type: application/zip

4. Test whether it will work or not

Finally, it is time to test our workflow whether it will work or not. To test it, first of all, lets create the version in using git,

git tag -a "v0.0.1-beta" -m "beta version testing"
git push --tags

After pushing this tag to the GitHub, it should trigger your GitHub action something like below,

Congratulations! you are successfully integrated this automation.

If you like this blog, please support me by subscribing to my YouTube channel: https://www.youtube.com/c/iamtekson

How to migrate database into production server in Django

Tek Kshetri — Fri, 20 May 2022 06:57:31 +0000

I search a lot about how to migrate the Django model as well as whole data from the development database to production, and I found lots of explanation about it (One of the good explanations is here) but did not find the easy solution. For this problem, I come up with my solution and I am explaining in this blog how to do that. Before moving to the core thing about this blog, I just want to raise one question and my thought about it.

Do I need to push my migration file to GitHub?

All individuals have their own perspectives. I was also confused about what is the best practice in beginning of my Django journey. After reading this answer from, I tried to push my migrations as well. But I think it is not a good way, so I removed the migrations from GitHub.

Okay, now lets start the core thing step by step:

1. Create the backup for your database

The first step is to create the database backup. In my case, I am using the PostgreSQL database. To create the backup file, I simply need to run the following command in the terminal,

pg_dump -U postgres -h localhost -d database > db_backup_2022_05_20.sql

where, postgres is the database user, localhost is the database host, database is the database name and db_backup_2022_05_20.sql is the backup file name.

2. Migrate the Django models to the server

Since this blog is only about how to migrate the database (not about the whole procedure of how to publish the Django site into production), I am only focusing on the database migration. After pulling the code to the server, the first step is to migrate the database tables and schema only by using the Django command,

# make migrations
python manage.py makemigrations

# migrate models
python manage.py migrate

3. Migrate the data

If you want the clean database to initialize the production environment, it is a good way to go, no further action is needed. But if you want to move all the data from the developer environment to production, you need to restore the development database. To do so, if you go with the normal method, you might get an error due to a foreign key, and also duplicated data issue. But to prevent this action and restore data only, the psql provides a nice command line. You just need to do the following,

pg_restore -U postgres -h IP -d database --disable-triggers --data-only db_backup_2022_05_12.sql

Where, postgres is the database user, ip is the server IP address, database is the database name and db_backup_2022_05_12.sql is the backup file location. If you want to know more about the pg_restore command, please check this official documentation.

This step might throw some error messages or warnings as well, but you can simply ignore those.

4. What next?

If you want to update the Django model, you can first test your model in the development environment. To update those changes on production, you just need to migrate the model as below on the server,

# make migrations
python manage.py makemigrations

# migrate models
python manage.py migrate

The migration file from the development and production environment will be different. If you check both databases from development and production, you will find the different data in the django_migration table.

Congratulations! you finally migrated the database with all the data from the development environment to production.

If you like this blog, please support me by subscribing to my YouTube channel: https://www.youtube.com/c/iamtekson

Docker remove all image, volume, container

Tek Kshetri — Fri, 13 May 2022 03:08:29 +0000

Here I am going to write about removing docker images, volumes and containers. To do so, first of all, you need to shutdown the docker container.

docker-compose down

After that, you can follow following method to remove required things,

# To remove all the containers
docker rm -f $(docker ps -a -q)

# To remove all the docker images
docker rmi -f $(docker images -a -q)

# To remove all the volumes
docker volume rm $(docker volume ls -q)

# To delete everything
docker system prune -a --volumes

Flood mapping using Sentinel 1 Imagery on Snap Toolbox

Tek Kshetri — Thu, 05 May 2022 02:04:44 +0000

The sentinel 1 imagery is the freely available SAR dataset. The dataset can be downloaded from the Copernicus Open Access Hub.

The snap Toolbox is an open source software for processing the sentinel products. The snap software provides the interactive GUI to process the raster dataset.

A flood is an overflow of water that submerges land that is usually dry. It is very common type of hazard which mainly occur in rainy season. The flood mapping can help to plan and mitigate the risk.

In this article, I am going to write about the flood mapping technique using SAR dataset provided by sentinel 1 imagery on Snap Toolbox. The overall methodology for flood mapping will be looks like this,

Need to upload an methodology image

Download data and load it into Snap Toolbox

You can download the data freely from Copernicus Open Access Hub. You need to download the data before and after flood event. Lets say, if the flood event happen in July 31, you need sentinel 1 dataset before July 31 and after July 31. You can filter the data as below,

Draw the boundary on your study area.
Under mission sentinel 1, select satellite platform as S1A_*
Select product type as GRD
Click the search button

The downloaded data will be in .zip format. Don't worry, Snap Toolbox can read the data directly from .zip format.

Please note that before applying any correction, the data will load in random orientation. I mean, the map will not be north oriented.

Mask data to the Area of Interest

To mask the dataset, you need to zoom the dataset to your area of interest. Under raster menu, you will find the Subset option, from where you can crop the data to the required area.

To view two image side by side, you might need to view > syncronise image views and Window > Tile evenly.

Multilooking

It is the process for reducing the size of the image. It might also reduce some spackles on the image. It is totally optional, if you need the high resolution output, don't do this step. The multilooking feature is available here: Radar > SAR Utilities > Multilooking.

Radiometric Calibration

The objective of SAR calibration is to provide imagery in which the pixel values can be directly related to the radar backscatter of the scene. Though uncalibrated SAR imagery is sufficient for qualitative use, calibrated SAR images are essential to quantitative use of SAR data. The feature is available here: Radar > Radiometric > Calibrate.

If you want to visualize the image more nicely, you can convert it to the dB by simply right click on the image > Linear to/from dB.

Terrain correction

Due to topographical variations of a scene and the tilt of the satellite sensor, distances can be distorted in the SAR images. Image data not directly at the sensor’s Nadir location will have some distortion. Terrain corrections are intended to compensate for these distortions so that the geometric representation of the image will be as close as possible to the real world. After applying this correction, the image will be correctly oriented. You can leave all the parameters as default value. This feature is available here: Radar > Geometry > Terrain correction > Range Doppler Terrain Correction.

Create stack

After applying the radiometric and geometric correction, you need to create the composite band, i.e. need to stack the both images into one. To do so, you need to convert the image to band and save the product. After that, you need to create the stack, the tool is available here: Radar > Coregistration > Stack Tools > Create Stack.

After that now you can visualize the products and see the difference between two maps. For better visualization you can make the RGB image using window > Open RGB Image Window as below,

Your final product will look like this,

If you like this blog, please subscribe to my YouTube channel for more contents related to GIS and Remote Sensing topics: https://www.youtube.com/c/iamtekson

References

ESA Echoes in Space - Hazard: Flood mapping with Sentinel-1

How to Access Jupyter Notebook Remotely on Webbrowser

Tek Kshetri — Tue, 19 Oct 2021 08:16:51 +0000

To access the remote jupyter notebook, you need to install and setup the jupyter notebook on server first. You can install the jupyter notebook using this tutorial. Now you can see the available options from jupyter notebook using this command,



jupyter notebook --help

You will see the output like below,

If you scroll little bit below, you will see the --ip and --port options as well,

Protect notebook with password

To protect jupyter notebook with the password, you need to type following command,



jupyter notebook password

The reason for you to make password is, When you access Jupyter notebook server on web browser, You have to enter the password.

Run the jupyter notebook on server



jupyter notebook –no-browser –ip=”your server IP Address” –port=8888

Note: Replace the ip address by your ip in above code.

From now, your notebook can be access from remote web-browsers.

you can go to chrome and type, http://{your ip address}:8888 to access the same jupyter notebook.

Congratulations! You successfully setup the jupyter notebook on the remote server.

If you like this blog, please subscribe to my youtube channel: https://www.youtube.com/c/iamtekson

Installation of GDAL on jupyter notebook

Tek Kshetri — Tue, 19 Oct 2021 07:54:54 +0000

Installation of GDAL in windows machine is always a challenging task. But anaconda environment on python makes it easier to install through conda distribution. In this blog, I will write about the installation of GDAL on jupyter notebook.

Step 1: Create conda environment

conda create --name venv

After creating the virtual environment, by default it will install some of the packages.

Step 2: Installation of gdal

conda install -c conda-forge gdal

Step 3: Installation of ipykernel

conda install -c anaconda ipykernel

Step 4: Add ipykernel and run jupyternotebook

python -m ipykernel install --user --name=venv
jupyter notebook

Congratulations! You successfully installed the GDAL on jupyter notebook.