demix-lib 1.14

version 1.14 of the DEMIX library

DEMIX library

The DEMIX Library allow you to get scores for specific DEMIX tiles and DEM.
You also can download DEMIX Tile associated DEM Layers like SourceMask, Heights, ...

---

Table of contents:

1. Installation
   

2. DEMIX lib functions
   2.1 Getting DEMIX Tile ID
   2.2 Getting Scores
   2.3 Getting DEM
   

3. Utility functions
   

4. Available DEMs and criterions
   4.1 Dem list
   4.2 Criterion list
   4.3 Layer list
   

5. Usage example
   5.1 Jupyter Notebook
   5.2 Getting a DEMIX layer and compute an indicator
   

---

Installation

To install the DEMIX library on your python environment :

pip install demix_lib

DEMIX lib functions

This section is a step-by-step guide on how to use the DEMIX lib functions. By getting through this guide, you'll learn how to:
* Get a DEMIX tile id from a given longitude and latitude
* Apply a criterion to a DEM, over a given DEMIX tile
* Retrieve a raster of DEM layer over a DEMIX tile

Getting DEMIX Tile ID

The DEMIX api enables you to get a DEMIX tile id from a given longitude and latitude.

import demix_lib as dl
lon = 14.44799
lat = 35.81923
print(dl.get_demix_tile_info(lon, lat))
print(dl.get_demix_tile_name(lon, lat))

Getting Scores

First thing first, you can use the demix api to get directly stats from the desired DEMIX Tile and Criterion
In order to get scores to specific dem and tile, you need to choose a criterion. The criterion list is available here. List of supported dems is also visible here.

import demix_lib as dl

#getting the list of implemented criterions
criterions = dl.get_criterion_list()
#getting the list of supported dems
dems = dl.get_supported_dem_list()

#defining the wanted DEMIX Tile name 
demix_tile_name = "N35YE014F"

#getting the score of each dem, for the criterion 
for dem in  dems:
    for criterion in criterions:
        print(dl.get_score(demix_tile_name=demix_tile_name, dem=dem, criterion=criterion))

Getting DEM

To go further : You can always use your own criterions by downloading the wanted layer on your DEMIX tile and apply custom code to it.
To download a DEM layer for a specific DEMIX Tile :

import demix_lib as dl
import matplotlib as plt #we use matplotlib to visualise the downloaded layer
from matplotlib import cm #we use cm to make a legend/colormap
from matplotlib.lines import Line2D #to add colored line in the legend

#defining wanted tile
demix_tile_name = "N35YE014F"
#asking for the SourceMask layer for the CopDEM_GLO-30 dem and the tile N64ZW019C
response = dl.download_layer(demix_tile_name=demix_tile_name,dem="CopDEM_GLO-30",layer="SourceMask")

#creating legend for the plot
legend_handle = list(map(int, response['values'].keys()))
legend_label = list(response['values'].values())
#defining the colormap for the layer (the layer has 6 values)
color_map = cm.get_cmap("rainbow",6)
#we use plt to look at the data
plt.imshow(response["data"], interpolation='none', cmap=color_map, vmin=0, vmax=6)
#creating legend values using the color map and the values stored
custom_handles = []
for value in legend_handle:
    custom_handles.append(Line2D([0], [0], color=color_map(value), lw=4))
plt.legend( custom_handles,legend_label)
#show the layer with custom legend and color map
plt.show()

Utility functions

The DEMIX lib give you some utility functions that allow you to get or print informations about currently implemented criterions, available DEMs, layers...

import demix_lib as dl

#get or show the layers that you can ask in a download_layer function
layer_list = dl.get_layer_list()
dl.print_layer_list()

#get or show the full dem list
dem_list = dl.get_dem_list()
dl.print_dem_list()

#get or show the supported dem list
supported_dem_list = dl.get_supported_dem_list()
dl.print_supported_dem_list()

#get or show the implemented criterion list
criterion_list = dl.get_criterion_list()
dl.print_criterion_list()

#get or show the implemented colormaps
criterion_list = dl.get_colormap_list()
dl.print_colormap_list()

Available DEMs and criterions

DEMs list

DEM name	supported
ALOS World 3D	yes
ASTERGDEM	yes
CopDEM GLO-30	yes
CopDEM GLO-90	yes
EU-DEM	yes
NASADEM	yes
SRTMGL1	yes

Criterion list

Criterion name	Criterion id	version	Author	Date	Category	Target	Description
Product fractional cover	A01	0.1	Peter Strobl	20211103	A-completeness	All	read
Valid data fraction	A02	0.1	Peter Strobl	20211103	A-completeness	All
Primary data	A03	0.1	Peter Strobl	20211103	A-completeness	All
Valid land fraction	A04	0.1	Peter Strobl	20211103	A-completeness	All
Primary land fraction	A05	0.1	Peter Strobl	20211103	A-completeness	All

Layer list

Layer name
Heights
validMask
SourceMask
landWaterMask

Usage example

Jupyter Notebook

A jupyter notebook has been made to demonstrate how can be used the DEMIX lib.
Download the latest Jupyter Notebook file of the following repository and execute it in you favorite jupyter environnement (like Colab for example) to get an idea of what is possible.

Jupyter notebook repository

Getting a DEMIX layer and compute an indicator

In this section, we will use the DEMIX lib to compute our own criterion on the SRTMGL1.

1 Define the criterion

First, we define a criterion

def max_height_custom_criterion(response):
    """take height data and return a score based on altitude, if a point is higher than Everest highest point, 
    score is reduce by maximum_value / everest_max_height *10"""
    maximum_value=response["data"][0][0]
    everest_max_height = 8848
    for line in response["data"]:
        if max(line) > maximum_value :
            maximum_value = max(line)
    #if result < 1, score = 100, else : 
    result = maximum_value / everest_max_height
    if result < 1 :
        return 100
    else :
        return 100 - (result*10)
    return score

2 Get the wanted layer

Second, we use the DEMIX lib to download the wanted tile and layer for SRTMGL1

lat = 27.986065
lon = 86.922623
response = dl.download_layer(demix_tile_name=dl.get_demix_tile_name(lon, lat),dem='SRTMGL1',layer='heights', print_request=False)

3 Compute the criterion on the layer

Finally, we compute the criterion on the downloaded layer and we plot the result

print(max_height_custom_criterion(response))