[PYTHON] Première analyse de données satellitaires par Tellus

introduction

Cet article a été publié en tant que jour 21 du Calendrier de l'avent Cisco 2019 entre Cisco Systems GK. Quelle est la connexion entre Cisco et les données satellites en premier lieu? Je pense qu'il y a une question, alors j'aimerais l'introduire en y compris.

Que pouvez-vous faire avec cet article

――Comprendre ce que sont les données satellitaires

• Comprendre ce qu'est la plate-forme de données satellitaires Tellus
• Comprendre comment utiliser l'environnement de développement Tellus
• Les données satellitaires peuvent être analysées à l'aide de l'environnement de développement Tellus
• Comprendre ce que sont NDVI et NDWI

En fin de compte, vous pouvez le faire

--Affichez des images satellite haute définition en sélectionnant la date et la position Mar, 31 juillet 2018 12:42:49 GMT, latitude nord 35,675 --35,605: longitude est 139,745 --139,835

--Visualiser l'état de la végétation (zone verte) à partir d'images satellites

--Quantifier l'état de la végétation (NDVI)

Qu'est-ce que la plateforme de données satellitaires Tellus?

Depuis la page officielle

Tellus est la première plate-forme de données par satellite ouverte et gratuite du Japon visant à créer un nouveau marché commercial utilisant les données satellitaires du gouvernement. Il multiplie les données multiples et fournit toutes les fonctions pour favoriser la création de nouvelles entreprises. https://www.tellusxdp.com/ja/about

Jusqu'à présent, l'utilisation des données satellitaires devait traiter des données d'image qui coûtaient des centaines de milliers de yens par feuille dans un format de données spécial. Il existe divers problèmes en termes de prix, de stockage et de ressources informatiques, et malgré l'abondance des données satellitaires, l'utilisation a été très limitée. Afin de résoudre ces problèmes, le ministère de l'Économie, du Commerce et de l'Industrie a lancé un projet de trois ans jusqu'en 2020, «Open & Free Government Satellite Data and Data Utilization Promotion Project», qui mettra fin à son existence. Ce sera Tellus.

Fonctionnalité

1. Toutes les données sont disponibles gratuitement (avec limite supérieure)
2. Non seulement les données satellitaires mais aussi les données au sol (flux humains, etc.) peuvent être utilisées.
3. Non seulement les données mais également les ressources d'analyse (CPU / GPU / stockage) peuvent être utilisées
4. Marketplace vous permet d'échanger des données, des applications et des algorithmes
5. Programmes de formation enrichis pour soutenir l'utilisation

Pertinence pour Cisco

Concernant la relation entre Cisco et le secteur spatial, Cisco a fréquemment introduit des routeurs IP dans l'espace en 2003 (satellite expérimental) et 2009 (satellite commercial). Il existe quatre types de satellites: les satellites météorologiques, les satellites d'observation, les satellites de positionnement et les satellites de communication. Parmi ceux-ci, Cisco a travaillé sur des satellites de communication dans le passé. https://www.cisco.com/c/ja_jp/about/newsroom/archives/us/2010/prod-072010b.html

Chez Tellus, diverses entreprises, instituts de recherche et organisations participent dans divers domaines comme xData Alliance, et Cisco participe également à partir du 21 février 2019. Cette fois, nous visons à créer une nouvelle entreprise en utilisant des satellites d'observation des types ci-dessus. https://www.xdataalliance.com

Récemment, une conception de service qui offre une nouvelle expérience urbaine appelée Tokyo Moonshot Challenge Nous organisons également un concours de création / réalisation d'idées, donc si vous êtes intéressé, rejoignez-nous.

Utilisons Tellus OS

Utilisons en fait Tellus pour utiliser les données satellites. La procédure d'utilisation est la suivante.

1. Enregistrement de l'utilisateur sur Tellus
2. Connectez-vous à Tellus OS
3. Accès à l'environnement de développement Tellus
4. Sélectionnez la langue à utiliser --R et Python peuvent être utilisés, mais cette fois nous utiliserons Python
5. Écrire du code dans Jupyter Notebook
6. Exécution et confirmation des résultats

Enregistrons-nous en tant qu'utilisateur avec Tellus

Accédez à Tellus, saisissez les informations requises et enregistrez-vous en tant qu'utilisateur. Il y a peut-être quelques endroits où entrer, mais ne vous découragez pas.

Utilisons l'environnement de développement Tellus

Après avoir terminé l'enregistrement de l'utilisateur, utilisons réellement Tellus. Il existe deux types d'environnements d'utilisation pour Tellus. Tout d'abord, connectez-vous à Tellus OS à partir du bouton en haut à droite ou sous la page Web Tellus.

1. Tellus OS Nous avons préparé un environnement dans lequel vous pouvez fonctionner de manière intuitive à l'aide de l'interface graphique. Les données sont préparées sous forme de préréglages, vous pouvez donc les utiliser à peu près pour l'analyse. Après avoir réduit dans une certaine mesure la cible d'analyse ici, si nécessaire, effectuez une analyse détaillée dans l'environnement de développement suivant.

2. Environnement de développement Tellus

Des API pouvant être utilisées à partir de Python et R sont disponibles. Non seulement l'API, mais également un environnement tel que l'informatique, le stockage et le GPU sont fournis. L'environnement de développement est accessible à partir du système d'exploitation Tellus. Vous pouvez accéder à l'environnement de développement en cliquant sur le bouton ci-dessous sur Tellus OS.

Une application est requise pour accéder à l'environnement de développement.

Méthode d'application de l'environnement de développement

1. Accédez à Ma page

2. Sélectionnez et postulez pour l'environnement de développement requis dans l'application d'environnement de développement sur Ma page. ―― Cela peut prendre un certain temps car les applications sont actuellement concentrées.

Enregistrement API TOKEN

Lorsque l'environnement de développement devient disponible, enregistrez API TOKEN. Vous pouvez vous inscrire depuis Ma page. Donnez à la clé le nom de votre choix.

Lancez Jupyter Note Book

Connectez-vous à Tellus OS et entrez dans l'environnement de développement.

Écrivons réellement le code

Une fois connecté, accédez au répertoire de travail. Créons un nouveau bloc-notes Python3.

Je n'expliquerai pas le Jupyter Notebook ici, mais c'est un environnement familier pour ceux qui l'ont utilisé. Les modules utilisés cette fois sont les suivants. Tout d'abord, importez-les.

#Importer les modules et bibliothèques requis
import numpy as np 
from skimage import io, color, img_as_ubyte, filters, transform
import requests
from io import BytesIO
from PIL import Image
import matplotlib.pyplot as plt
%matplotlib inline
import math

Ici, nous aimerions vous présenter le satellite utilisé cette fois.

Spécifiez le jeton d'accès.

#API de jeton d'accès à l'API_Magasin dans TOKEN
API_TOKEN = 'YOUR TOKEN HERE'

Cette fois, je voudrais acquérir une image de la zone autour de la baie de Tokyo, alors entrez la latitude et la longitude comme suit.

#Latitude minimale
min_lat = 35.675
#Valeur minimale de la longitude
min_lon = 139.745
#Latitude maximum
max_lat = 35.605
#Valeur maximale de la longitude
max_lon = 139.835

Spécifiez l'URL, l'en-tête et les paramètres d'acquisition des données satellite à l'aide de l'API.

#Spécifiez l'URL du serveur, l'en-tête et les paramètres de l'image satellite à acquérir
# ASNARO-URL de 1
urls_ASNARO1 = 'https://gisapi.tellusxdp.com/api/v1/asnaro1/scene'
#entête
headers = {'Authorization': 'Bearer ' + API_TOKEN}
#Spécifiez les paramètres (valeurs maximum et minimum de latitude et longitude)
parameter = { 'min_lat': min_lat, 'min_lon': min_lon, 'max_lat': max_lat, 'max_lon': max_lon}

L'URL et les paramètres du serveur se trouvent dans la référence API Tellus. Référence API: https://www.tellusxdp.com/ja/dev/api

Il existe deux principaux types d'API de données satellitaires.

1. Quel genre de scène chaque satellite a
2. Données d'image pour chaque scène, données d'image pour chaque longueur d'onde, données SAR

Commençons par vérifier le type de scène d'ASNARO-1.

#Recherchez la scène qui a observé la zone spécifiée dans le module de requêtes et obtenez la liste au format JSON
r_ASNARO1 = requests.get(urls_ASNARO1, params=parameter, headers=headers).json()

#Montrons le contenu
r_ASNARO1[0]
{'acquisitionDate': 'Wed, 31 Oct 2018 12:31:16 GMT',
 'clat': 35.6602740014593,
 'clon': 139.701407725281,
 'cloudCover': 20.0,
 'entityId': '20190115064426419_AS1',
 'max_lat': 35.7191765745438,
 'max_lon': 139.786374532312,
 'min_lat': 35.6013160074949,
 'min_lon': 139.61632039109,
 'path': 0,
 'productId': '20190115064426419_AS1_D01_L1B',
 'row': 0,
 'thumbs_url': 'https://tile.tellusxdp.com/thums/ASNARO-1/20190115064426419_AS1.PNG'}

Vérifions le nombre de données de prise de vue dans cette plage de latitude et de longitude

len(r_ASNARO1)
28

J'ai trouvé qu'il y avait 28 feuilles. Montrons le contenu.

# ASNARO-Afficher 1 résultats de recherche
print("ASNARO-Liste de 1[Date et heure de prise de vue, entityId, productId, cloudCover]")
for res in r_ASNARO1:
    print(", ".join([res['acquisitionDate'],
        str(res['entityId']), str(res['productId']), str(res['cloudCover'])]))

ASNARO-Liste de 1[Date et heure de prise de vue, entityId, productId, cloudCover]
Wed, 31 Oct 2018 12:31:16 GMT, 20190115064426419_AS1, 20190115064426419_AS1_D01_L1B, 20.0
Sat, 20 Oct 2018 12:52:04 GMT, 20181224064142828_AS1, 20181224064142828_AS1_D01_L1B, 19.0
Tue, 31 Jul 2018 12:42:49 GMT, 20181224064003777_AS1, 20181224064003777_AS1_D01_L1B, 0.0
Sat, 30 Jun 2018 12:17:46 GMT, 20181224062516884_AS1, 20181224062516884_AS1_D01_L1B, 13.0
Fri, 08 Jun 2018 12:25:21 GMT, 20190115062640786_AS1, 20190115062640786_AS1_D01_L1B, 20.0
Sat, 02 Jun 2018 12:36:46 GMT, 20181224062257563_AS1, 20181224062257563_AS1_D01_L1B, 18.0
Sat, 21 Apr 2018 12:38:02 GMT, 20181225033937173_AS1, 20181225033937173_AS1_D01_L1B, 0.0
Sun, 25 Mar 2018 12:27:00 GMT, 20181224062059947_AS1, 20181224062059947_AS1_D01_L1B, 0.0
Wed, 03 Jan 2018 15:30:59 GMT, 20181224061906786_AS1, 20181224061906786_AS1_D01_L1B, 0.0
Tue, 02 Jan 2018 02:16:36 GMT, 20181224061858253_AS1, 20181224061858253_AS1_D01_L1B, 0.0
Fri, 29 Dec 2017 15:24:58 GMT, 20181224061846634_AS1, 20181224061846634_AS1_D01_L1B, 1.0
Sun, 05 Nov 2017 13:55:39 GMT, 20181224061816204_AS1, 20181224061816204_AS1_D01_L1B, 0.0
Sun, 09 Jul 2017 15:40:45 GMT, 20181224061651885_AS1, 20181224061651885_AS1_D01_L1B, 0.0
Mon, 22 May 2017 14:06:36 GMT, 20181224061523296_AS1, 20181224061523296_AS1_D01_L1B, 1.0
Sat, 06 May 2017 15:29:27 GMT, 20181224061506752_AS1, 20181224061506752_AS1_D01_L1B, 8.0
Tue, 04 Apr 2017 15:27:01 GMT, 20181224061413592_AS1, 20181224061413592_AS1_D01_L1B, 1.0
Fri, 24 Mar 2017 13:57:55 GMT, 20181224061303679_AS1, 20181224061303679_AS1_D01_L1B, 0.0
Sat, 18 Mar 2017 15:39:14 GMT, 20181224061254113_AS1, 20181224061254113_AS1_D01_L1B, 2.0
Mon, 24 Oct 2016 14:10:19 GMT, 20181224060959386_AS1, 20181224060959386_AS1_D01_L1B, 0.0
Fri, 17 Jun 2016 15:39:32 GMT, 20181224045149110_AS1, 20181224045149110_AS1_D01_L1B, 29.0
Thu, 05 May 2016 14:08:24 GMT, 20181223152759390_AS1, 20181223152759390_AS1_D01_L1B, 0.0
Fri, 18 Mar 2016 15:31:58 GMT, 20181223152702426_AS1, 20181223152702426_AS1_D01_L1B, 0.0
Mon, 30 Nov 2015 14:31:57 GMT, 20190117124820618_AS1, 20190117124820618_AS1_D01_L1B, 33.0
Tue, 03 Nov 2015 14:32:11 GMT, 20181225123811442_AS1, 20181225123811442_AS1_D01_L1B, 0.0
Sun, 25 Oct 2015 03:35:55 GMT, 20181223152305607_AS1, 20181223152305607_AS1_D01_L1B, 0.0
Thu, 06 Aug 2015 03:12:35 GMT, 20181223060118912_AS1, 20181223060118912_AS1_D01_L1B, 13.0
Wed, 05 Aug 2015 14:11:45 GMT, 20181223060109423_AS1, 20181223060109423_AS1_D01_L1B, 0.0
Sun, 28 Jun 2015 12:41:27 GMT, 20181225122707116_AS1, 20181225122707116_AS1_D01_L1B, 10.0

Ici, la «couverture nuageuse» est appelée le taux de couverture nuageuse, et c'est une valeur numérique de la quantité de nuages inclus dans l'image. Cette fois, il ne s'agit pas d'un radar à ouverture composite qui n'est pas affecté par les nuages appelés SAR, mais d'une image satellite optique normale, nous allons donc sélectionner les dernières données ci-dessous qui n'ont pas de couverture nuageuse.

Tue, 31 Jul 2018 12:42:49 GMT, 20181224064003777_AS1, 20181224064003777_AS1_D01_L1B, 0.0

Ensuite, obtenons les données d'image pour chaque scène à l'aide de la deuxième API. ASNARO-1 utilise productId pour obtenir l'image. Stockons également le entityId ici.

#Sélectionnez la scène que vous souhaitez obtenir
#Sélectionné ASNARO-1 Stocker l'ID de produit et l'ID d'entité de l'image satellite
ASNARO1_entityId = "20181224064003777_AS1"
ASNARO1_productId = "20181224064003777_AS1_D01_L1B"

Ici, je vais vous expliquer la mosaïque d'image et le grossissement. Il est exprimé comme (z = niveau de zoom, x = tile_x, y = tile_y), mais dans Tellus, il est possible d'obtenir 256 x 256 images de tuiles pour chaque niveau de zoom entre Z = 0-18 avec l'API. .. Cela utilise la projection Web Mercator, qui est une découpe de la carte du monde projetée par la projection Mercator dans la plage de 180 ° Est à 180 ° Ouest et 85,0511 ° Nord à 85,0511 ° Sud.

Lorsque Z = 1

Lorsque Z = 1

Lorsque Z = 2

Lorsque Z = 7

Lorsque Z = 12

Au fait, il est possible de trouver la plage que vous souhaitez afficher cette fois avec des tuiles de Tellus OS comme celle-ci, mais dans ce cas, sélectionnez "Sélection de données" → "Image de tuile" comme indiqué ci-dessous.

Cependant, s'il est gênant de faire une telle chose à chaque fois, je considérerai comment implémenter une méthode pour transformer la latitude et la longitude en coordonnées de tuile en Python. Je m'abstiendrai d'utiliser l'algorithme détaillé car il sera long, mais le code suivant peut être utilisé pour la conversion.

#Coordonnées de la vignette, y compris la latitude et la longitude spécifiées (x, y,z) est calculé.
#Une fonction qui calcule les coordonnées de tuile correspondantes avec la latitude / longitude et le niveau de zoom z comme entrées.
#Vous pouvez trouver le niveau de zoom z que vous pouvez spécifier dans la référence API sur la page Tellus Developers.
# https://www.tellusxdp.com/ja/dev/api
def LatLon2Tile(lat,lon, z):
    L = 85.05112878
    tileX = int( (2**(z+7)) * ((lon/180) + 1) )
    tileY = int( (2**(z+7)/math.pi) * (-1 * np.arctanh(math.sin(lat * math.pi/180)) + np.arctanh(math.sin(L * math.pi/180))) )
    return int(tileX/256), int(tileY/256)

#Coordonnées du centre de cette zone désignée(longitude latitude)
center_lat = (min_lat + max_lat) / 2
center_lon = (min_lon + max_lon) / 2
#Cette fois, réglez le niveau de zoom z sur 12.
z = 12
#Obtenir les coordonnées des tuiles
x, y = LatLon2Tile(center_lat,center_lon, z)

Acquérons en fait une image satellite en utilisant cette fonction. Cette fois, nous allons acquérir des images pour chaque bande RVB et NIR (proche infrarouge).

# ASNARO-Obtenez 1 image satellite
#Spécifiez l'URL du serveur
url_ASNARO1 =  'https://gisapi.tellusxdp.com/blend/asnaro1'
#Déterminer l'attribution de bande
query_ASNARO1 = "r=4&g=3&b=2" 
res_ASNARO1 = requests.get("{}/{}/{}/{}/{}.png?{}".format(
                url_ASNARO1,
                ASNARO1_productId,
                z, x, y,
                query_ASNARO1),
                headers={"Authorization": "Bearer " + API_TOKEN})
RGB_ASNARO1 = np.asarray(Image.open((BytesIO(res_ASNARO1.content))))
#Changer le type de données en entier
RGB_ASNARO1 = RGB_ASNARO1.astype(np.uint8)

Importer comme R = Band4, G = Band3, B = Band2 par attribution de bande. L'image acquise est capturée sous la forme d'un tableau numpy en 4 dimensions appelé RGBA (A = Alpha Chennel).

# 7. ASNARO-Obtenez 1 image mono-bande(Rouge, bleu, vert, proche infrarouge)
#Convertir en un tableau bidimensionnel à bande unique de rouge, bleu et vert
R_ASNARO1 = RGB_ASNARO1[:,:,0]
G_ASNARO1 = RGB_ASNARO1[:,:,1]
B_ASNARO1 = RGB_ASNARO1[:,:,2]

# ASNARO-Changer l'affectation de bande de 1 (rouge: bande 4, vert: bande 4, bleu: bande 4)
query_ASNARO1 = "r=6&g=6&b=6" 
# ASNARO-1 Obtenir une image satellite
res_ASNARO1 = requests.get("{}/{}/{}/{}/{}.png?{}".format(
                url_ASNARO1, 
                ASNARO1_productId, 
                z, x, y, 
                query_ASNARO1),
                headers=headers)
#Tableau bidimensionnel NumPy d'images monobandes dans le proche infrarouge
NIR_ASNARO1 = np.asarray(Image.open((BytesIO(res_ASNARO1.content))))
NIR_ASNARO1 = NIR_ASNARO1[:,:,0].astype(np.uint8)

Ensuite, capturez NIR proche infrarouge = Band6.

L'image capturée est affichée dans la vraie composition des couleurs, qui est une méthode de composition proche de l'œil humain. Ci-dessous, une image de la vraie composition des couleurs.

# 9.Vraie composition des couleurs
#R: bande rouge, G: bande verte, B: bande bleue
# ASNARO-1
true_ASNARO1 = np.dstack((R_ASNARO1, G_ASNARO1, B_ASNARO1))
# ASNARO-1 Affichage de l'image satellite
plt.figure(figsize=(20,20)) #Taille de l'écran spécifiée en pouces 20 x 20 pouces
plt.imshow(true_ASNARO1)
plt.show()

Puisqu'elle est acquise à 256 x 256 pixels, elle sera considérablement floue si elle est étirée à ce point, mais il semble que certaines informations telles que l'état de l'afflux des dépôts du jardin Hama Rikyu et des rivières puissent être acquises.

Est-ce inutile avec Google Earth?

Jusqu'à présent, je pense avoir écrit un code plutôt gênant, mais je pense qu'il est possible de l'utiliser plus facilement depuis GCP sur Google Earth sans faire cela. Je pense que certaines personnes le pensent. J'ai fait. C'est vraiment ce que vous visez, donc c'est parfaitement bien si vous pouvez atteindre vos objectifs avec Google Earth ou toute autre source de données.

Cependant, les données satellitaires ont un certain nombre de fonctionnalités que d'autres données n'ont pas. Bien qu'il s'agisse d'une enquête indépendante, j'ai résumé les caractéristiques de chacun ci-dessous.

Comme mentionné ci-dessus, les avantages des données satellitaires sont l'abondance de données passées, des capteurs de différentes longueurs d'onde et une détection active par un radar à ouverture synthétique appelé SAR. En les utilisant, il devient possible d'obtenir des informations qui ne pourraient pas être obtenues avec la lumière visible.

En outre, Tellus fournit également des données obtenues à partir d'autres que des satellites, telles que des données de température et de débit artificiel, ce qui est également avantageux à cet égard.

Que sont NDVI et NDWI?

Alors, quelles sont les informations qui n'ont pas pu être obtenues avec la lumière visible? https://sorabatake.jp/5192/

Le satellite d'observation étant équipé de capteurs optiques de différentes longueurs d'onde, les longueurs d'onde qui peuvent être acquises diffèrent pour chaque satellite. Comme mentionné ci-dessus, les longueurs d'onde des ondes électromagnétiques absorbées et réfléchies par l'objet sont différentes, de sorte que diverses informations peuvent être obtenues en les combinant. Les combinaisons typiques sont connues comme suit.

https://sorabatake.jp/5192/

Parmi eux, le NDVI, qui est un indice de la quantité de plantes envahies, est un indice couramment utilisé. Il existe un indice appelé NDWI, qui est un indicateur de la quantité d'eau présente. Cette fois, le pixel de chaque image est indiqué par uint8 $ (2 ^ 8 = 256) $, il est donc indiqué par une valeur numérique de 0 à 255. NDVI et NDWI seront affichés normalisés entre (-1 → 1).

Indice de végétation normalisé NDVI (combinaison du rouge (R) et du proche infrarouge (NIR))

NDVI = \frac{R - NIR}{R + NIR}

Indice d'eau normalisé NDWI (combinaison de rouge (R) et infrarouge à courte longueur d'onde (SWIR))

NDWI = \frac{R - SWIR}{R + SWIR}

Ensuite, une méthode de composition appelée composition de couleur naturelle est effectuée. Il s'agit d'une méthode de composition de couleurs dans laquelle R = NIR (proche infrarouge) est utilisé au lieu de R = R. Vous pouvez afficher la plante en vert. L'image spécifique est la suivante.

# 10.Composition de couleur naturelle
#R: bande rouge, G: bande proche infrarouge, B: bande verte
# ASNARO-1
natural_ASNARO1 = np.dstack((R_ASNARO1, NIR_ASNARO1, G_ASNARO1))

# ASNARO-1 Affichage de l'image satellite
plt.figure(figsize=(20,20)) #Taille de l'écran spécifiée en pouces 20 x 20 pouces
plt.imshow(natural_ASNARO1)
plt.show()

La partie de la végétation est visualisée en vert et la zone de végétation peut être affichée plus clairement que lorsqu'elle est visualisée avec une vraie composition de couleurs.

Ensuite, visualisons le NDVI décrit ci-dessus. Mettez R et NIR dans la formule.

# 1. NDVI
#Changer le type de données de uint8 en float32
NIR_ASNARO1 = NIR_ASNARO1.astype(np.float32)
R_ASNARO1 = R_ASNARO1.astype(np.float32)

#Calculer le NDVI
NDVI_ASNARO1 = (NIR_ASNARO1 - R_ASNARO1) / (NIR_ASNARO1 + R_ASNARO1)

plt.figure(figsize=(20,20)) #Taille de l'écran spécifiée en pouces 6 pouces x 6 pouces
plt.imshow(NDVI_ASNARO1, cmap='Reds')
plt.colorbar()
plt.show()

J'ai pu calculer le NDVI et quantifier l'indice de végétation. Malheureusement, ASNARO-1 n'a pas de capteur SWIR (Short Wave Infrared), il n'est donc pas possible de calculer le NDWI. Cependant, même dans un tel cas, il est possible de calculer le NDWI en utilisant les données de Landsat 8 équipé de SWIR. Cependant, dans le cas de Landsat8, seul le grossissement de Z = 12 est pris en charge, donc la rugosité de cette image est la limite. De cette manière, Tellus peut commuter et utiliser les données de divers satellites en fonction de l'objectif.

Mais l'image n'est-elle pas rude après tout?

Je pense que la résolution est inférieure à l'image affichée au début de l'article, mais cela ne signifie pas que le navigateur Web n'a pas pu se charger. Chaque niveau de zoom capture une image avec une résolution de 256x256, donc si vous souhaitez capturer une image de définition plus élevée, par exemple, vous devez augmenter le niveau de zoom. Le niveau de zoom varie d'un satellite à l'autre, mais même au sein d'un même satellite, il varie d'un capteur à l'autre. Dans ASNARO-1, le niveau de zoom maximum est de 18 pour un capteur optique qui combine RVB, mais pour un capteur optique pour chaque bande comme cette fois, le niveau de zoom maximum est de 16. Les détails des spécifications de chaque satellite sont décrits en détail dans les pages suivantes, veuillez donc les consulter si nécessaire. https://www.tellusxdp.com/ja/dev/data

Maintenant, lorsque j'essaye d'obtenir une image haute résolution (Z = 16), la plage est réduite car elle est de 256x256 pixels. Cependant, si vous essayez d'étendre la plage (Z = 12), la résolution diminuera en raison de 256x256 pixels. Dans un tel cas, il est possible d'acquérir l'image avec une résolution de niveau Z = 16 dans la plage de Z = 12 en concaténant et en affichant les images de Z = 16.

def get_combined_image(get_image_func, z, topleft_x, topleft_y, size_x=1, size_y=1, option={}, params={}):
    """
Obtenez l'image de tuile combinée
    Parameters
    ----------
    get_image_func : function 
Méthode d'acquisition d'image de tuile
L'argument est z, x, y, option, params
    z : int 
Facteur de zoom de la mosaïque
    topleft_x : int 
Coordonnée X de la vignette supérieure gauche
    topleft_y : int 
Coordonnée Y de la tuile supérieure gauche
    size_x : int 
Nombre de tuiles pouvant être connectées dans le sens de la longitude
    size_y : int 
Nombre de tuiles pouvant être connectées dans le sens de la latitude
    option : dict 
Options de chemin de l'API(z,x,y exclu)
    params : dict 
Paramètres de requête
    Returns
    -------
    combined_image: ndarray
Image de tuile combinée
    """
    rows = []
    blank = np.zeros((256, 256, 4), dtype=np.uint8)
    
    for y in range(size_y):
        row = []
        for x in range(size_x):
            try:
                img = get_image_func(z, topleft_x + x, topleft_y + y, option)
            except Exception as e:
                img = blank
                
            row.append(img)
        rows.append(np.hstack(row))
    return  np.vstack(rows)

Ici, nous allons introduire un algorithme qui crée d'abord une matrice numpy vide, puis insère les images une par une. Lorsque Z augmente de 1, l'image sera quadruplée et quadruplée, donc si vous passez de Z = 12 à Z = 16, $ 4 ^ {4} = 256 $ carreaux seront alignés. Ceci est illustré ci-dessous.

Le code ci-dessus en est la mise en œuvre réelle.

def get_asnaro1_image(z, x, y, option={}, params={}, query=''):
    """
    ASNARO-Obtenir 1 image de tuile
    Parameters
    ----------
    z : int 
Facteur de zoom de la mosaïque
    x : int 
Coordonnée X de la tuile
    y : int 
Coordonnée Y de la tuile
    option : dict 
Options de chemin de l'API(productId)
    params : dict 
Paramètres de requête
    Returns
    -------
    img: ndarray
Image de tuile
    """
    url = 'https://gisapi.tellusxdp.com/blend/asnaro1/{}/{}/{}/{}.png?{}'.format(option['productId'], z, x, y, query)
    headers = {
        'Authorization': 'Bearer' + API_TOKEN
    }
    r = requests.get(url, headers=headers, params=params)
    if not r.status_code == requests.codes.ok:
        r.raise_for_status()
    return io.imread(BytesIO(r.content))

Cette fois, j'ai écrit l'algorithme pour acquérir l'image 256x256 qui est l'image originale à assembler comme ci-dessus. Dans ce qui suit, nous allons acquérir des images comme R = Band4, G = Band3, B = Band2 pour une vraie composition de couleurs.

# ASNARO-Obtenez 1 image satellite
def rgb_asnaro1(z, x, y, option):
    #Spécifiez l'URL du serveur
    url_ASNARO1 =  'https://gisapi.tellusxdp.com/blend/asnaro1'
    #Déterminer l'attribution de bande
    query_ASNARO1 = "r=4&g=3&b=2" 
    res_ASNARO1 = requests.get("{}/{}/{}/{}/{}.png?{}".format(
                url_ASNARO1,
                option['productId'],
                z, x, y,
                query_ASNARO1),
                headers={"Authorization": "Bearer " + API_TOKEN})
    RGB_ASNARO1 = np.asarray(Image.open((BytesIO(res_ASNARO1.content))))
    #Changer le type de données en entier
    #RGB_ASNARO1 = RGB_ASNARO1.astype(np.uint8)
    return RGB_ASNARO1.astype(np.uint8)

Dans ce qui suit, nous allons acquérir des images comme R = Band6, G = Band6, B = Band6 pour une composition de couleurs naturelles.

# ASNARO-Obtenez 1 image satellite
def nir_asnaro1(z, x, y, option):
    #Spécifiez l'URL du serveur
    url_ASNARO1 =  'https://gisapi.tellusxdp.com/blend/asnaro1'
    #Déterminer l'attribution de bande
    query_ASNARO1 = "r=6&g=6&b=6" 
    res_ASNARO1 = requests.get("{}/{}/{}/{}/{}.png?{}".format(
                url_ASNARO1,
                option['productId'],
                z, x, y,
                query_ASNARO1),
                headers={"Authorization": "Bearer " + API_TOKEN})
    RGB_ASNARO1 = np.asarray(Image.open((BytesIO(res_ASNARO1.content))))
    #Changer le type de données en entier
    #RGB_ASNARO1 = RGB_ASNARO1.astype(np.uint8)
    return RGB_ASNARO1.astype(np.uint8)

Ci-dessous, les coordonnées du haut à gauche X et du haut à gauche Y sont calculées à partir des coordonnées du centre. +1 est la correction effectuée car si 1/2 est soustrait des coordonnées du centre, les coordonnées retourneront trop.

z = 16
size_x = 16
size_y = 16
x, y = LatLon2Tile(center_lat,center_lon, z)
topleft_x = int(x - size_x / 2 + 1)
topleft_y = int(y - size_y / 2 + 1)
option = {
    'productId': ASNARO1_productId
}
query_ASNARO1 = "r=4&g=3&b=2" 

Entrez les paramètres ci-dessus pour la fonction qui assemble réellement les images composites de vraies couleurs.

combined = get_combined_image(rgb_asnaro1, z, topleft_x, topleft_y, size_x, size_y, option, params_ASNARO1)

Nous ajouterons également les paramètres ci-dessus à la fonction qui connecte réellement les images composites aux couleurs naturelles.

combined_nir = get_combined_image(nir_asnaro1, z, topleft_x, topleft_y, size_x, size_y, option, query_ASNARO1)

Les images sont stockées dans un tableau pour chaque bande.

# ASNARO-Obtenez 1 image mono-bande(Rouge, bleu, vert, proche infrarouge)
#Convertir en un tableau bidimensionnel à bande unique de rouge, bleu et vert
COMR_ASNARO1 = combined[:,:,0].astype(np.uint8)
COMG_ASNARO1 = combined[:,:,1].astype(np.uint8)
COMB_ASNARO1 = combined[:,:,2].astype(np.uint8)

#Tableau bidimensionnel NumPy d'images monobandes dans le proche infrarouge
COMNIR_ASNARO1 = combined_nir[:,:,0].astype(np.uint8)

Tout d'abord, la vraie composition des couleurs.

#Vraie composition des couleurs
#R: bande rouge, G: bande verte, B: bande bleue
# ASNARO-1
true_COMASNARO1 = np.dstack((COMR_ASNARO1, COMG_ASNARO1, COMB_ASNARO1))
# ASNARO-1 Affichage de l'image satellite
plt.figure(figsize=(20,20)) #Taille de l'écran spécifiée en pouces 20 x 20 pouces
plt.imshow(true_COMASNARO1)
plt.show()

Vous avez pu obtenir une image assez haute définition. En termes de pixels, c'est une image de 256 x 16 = 4096 pixels.

Vient ensuite la composition des couleurs naturelles.

#Composition de couleur naturelle
#R: bande rouge, G: bande proche infrarouge, B: bande verte
# ASNARO-1
natural_COMASNARO1 = np.dstack((COMR_ASNARO1, COMNIR_ASNARO1, COMG_ASNARO1))

# ASNARO-1 Affichage de l'image satellite
plt.figure(figsize=(20,20)) #Taille de l'écran spécifiée en pouces 20 x 20 pouces
plt.imshow(natural_COMASNARO1)
plt.show()

J'ai pu obtenir une image assez haute définition ici.

# NDVI
#Changer le type de données de uint8 en float32
COMNIR_ASNARO1 = COMNIR_ASNARO1.astype(np.float32)
COMR_ASNARO1 = COMR_ASNARO1.astype(np.float32)

#Calculer le NDVI
COMNDVI_ASNARO1 = (COMNIR_ASNARO1 - COMR_ASNARO1) / (COMNIR_ASNARO1 + COMR_ASNARO1)

plt.figure(figsize=(20,20)) #Taille de l'écran spécifiée en pouces 6 pouces x 6 pouces
plt.imshow(COMNDVI_ASNARO1, cmap='Reds')
plt.colorbar()
plt.show()

Une image assez haute définition est également produite pour NVDI.

prime

Cet article décrit principalement comment utiliser les données satellites, mais en ce qui concerne les images, vous ne voulez pas essayer la reconnaissance d'images. Je ne le mentionnerai pas dans cet article, mais bien sûr, la reconnaissance d'image est également possible sur Tellus. Les résultats de la détection d'un navire amarré à l'aide du modèle d'apprentissage automatique [^ 3] sont les suivants.

Nous avons extrait ceux avec une certitude de 0,8 ou plus, mais nous avons pu trouver un total de 326 navires ancrés. Nous avons également détecté des navires amarrés dans la rivière vers la terre. Puisque les navires qui naviguent sont exclus de la cible de détection, on peut voir que les navires qui agitent ne sont pas détectés.

Reference

• Sorahata
• Gestion des actualités sur l'utilisation de Tellus et du secteur spatial
• Tellus --Cliquez ici pour accéder au système d'exploitation Tellus et à l'environnement de développement

Avertissement

Les opinions exprimées sur ce site et les commentaires correspondants sont les opinions personnelles de l'affiche et non les opinions de Cisco. Le contenu de ce site est fourni à titre informatif uniquement et n'est pas destiné à être approuvé ou exprimé par Cisco ou toute autre partie. En publiant sur ce site Web, chaque utilisateur est seul responsable du contenu de toutes les informations publiées, liées ou autrement téléchargées, et décline Cisco de toute responsabilité relative à l'utilisation de ce site Web. Je suis d'accord.

[^ 1]: basé sur les futures données satellite embarquées [^ 2]: Il existe des méthodes fréquentes telles que la constellation de satellites