Suite

Itérer à travers les rasters dans les sous-dossiers à l'aide de Model Builder


J'ai un dossier de répertoire de données de précipitations ; dans ce dossier se trouvent des sous-dossiers pour les années 1901-2014. Dans chacun de ces sous-dossiers se trouvent 12 fichiers de grille .asc ; chaque fichier représente un mois de l'année (c'est-à-dire de janvier à décembre).

J'essaie de créer un modèle qui parcourra chacun de ces sous-dossiers et effectuera un calcul sur les 12 fichiers de grille (par exemple : calculez les précipitations annuelles totales). Je souhaiterais peut-être effectuer d'autres calculs, mais pour l'instant, j'aimerais simplement que le modèle fonctionne.

j'ai essayé le Itérer l'espace de travail fonctionner avec le Calculatrice raster, et le Itérer les rasters fonctionner avec le Calculatrice raster, mais je ne pouvais pas non plus travailler comme je le voulais.

j'ai aussi essayé Itérer les rasters avec Collecter des valeurs, et Statistiques de cellule - mais cela ne fonctionne pas non plus.

Voici les modèles que j'ai essayé :


Face à un problème comme celui-ci, j'utiliseos.marche()qui renvoie tous les fichiers, puis regarde si les fichiers correspondent à ce que je veux par extension, voici un exemple pour les fichiers de formes :

importer sys, os, arcpy InFolder = sys.argv[1] pour (chemin, répertoires, fichiers) dans os.walk(InFolder) : pour ThisFile dans les fichiers : fName,fExt = os.path.splitext(ThisFile) if fExt. upper() == ".SHP": fc = chemin + "" + ThisFile

ChangementfExt.upper() == ".SHP":àfExt.upper() == ".ASC":puis fonctionner normalement avecfcétant le chemin complet vers l'ensemble de données.

L'autre option est de mettre tous les rasters manuellement… ou semi manuellement :

Ouvrez une invite de commande dans votre dossier de base et tapez :

DIR *.ASC /B/S

Ce qui donne une liste de tous les fichiers ASCII dans tous les sous-dossiers… s'il y en a trop à sélectionner, essayez de rediriger vers un fichier texte :

DIR *.ASC /B/S > ASC_File_List.txt DÉMARRER LE BLOC-NOTES ASC_File_List.txt

Ensuite, sélectionnez tout, copiez et collez dans l'outil.


Pour que le modèle Collect Values ​​fonctionne sur des sous-dossiers individuels, vous devrez utiliser un autre sous-modèle imbriqué dans votre fichier . Créez un modèle avec l'itérateur Iterate Workspaces avec récursif défini sur false. Modifiez ensuite votre deuxième modèle afin qu'il nécessite l'espace de travail (c'est-à-dire le sous-dossier) en tant que paramètre, et alimentez l'espace de travail du modèle principal dans l'opération Itérer les rasters. Le modèle principal effectuera alors tous les calculs que vous souhaitez sur chaque dossier dans l'ordre. Assurez-vous simplement de définir vos variables de sorte que le nom du fichier de sortie soit conservé dans le même dossier ou nommé quelque chose qui dépend du chemin.


Chemin et nom de la mosaïque à laquelle les données raster seront ajoutées.

Le type raster est spécifique aux produits d'imagerie. Il identifie les métadonnées, telles que le géoréférencement, la date d'acquisition et le type de capteur, ainsi qu'un format raster.

Si vous utilisez un type de raster LAS, LAS ou MNT, un fichier .art doit être utilisé, dans lequel la taille de cellule est spécifiée.

Chemin et nom du fichier, du dossier, du jeu de données raster, de la mosaïque, de la table ou du service.

Tous les choix d'entrée ne seront pas disponibles. Ceux disponibles dépendront du type de raster sélectionné.

  • Jeu de données : vous permet de sélectionner un jeu de données géographiques ArcGIS, tel qu'un raster ou une mosaïque dans une géodatabase ou une table.
  • Espace de travail : vous permet de sélectionner un dossier contenant plusieurs jeux de données raster. Le dossier peut contenir des sous-dossiers. Ceci est affecté par les paramètres Inclure les sous-dossiers et Filtre de données d'entrée.
  • Fichier : vous permet de sélectionner un ou plusieurs jeux de données raster stockés dans un dossier sur le disque, un fichier de définition de service d'imagerie ( .ISDef ) et un fichier de définition de processus raster ( .RPDef ). De plus, la liste de fichiers ignorera tous les fichiers qui ne correspondent pas au type de raster ajouté. Ne l'utilisez pas avec des formats de fichiers qui sont des jeux de données raster, tels que des fichiers TIFF ou MrSID, utilisez Dataset .
  • Service : vous permet de sélectionner un service WCS, de carte ou d'imagerie, ou un fichier de couche de service Web.

Calcule les plages de tailles de cellule de chaque raster de la mosaïque. Ces valeurs sont écrites dans la table attributaire dans les colonnes minPS et maxPS.

  • UPDATE_CELL_SIZES —Les plages de tailles de cellule seront calculées pour tous les rasters de la mosaïque. C'est la valeur par défaut.
  • NO_CELL_SIZES —Les plages de taille de cellule ne seront pas calculées.

Génère ou met à jour le polygone de limite d'une mosaïque. Par défaut, la limite fusionne tous les polygones d'empreinte pour créer une seule limite représentant l'étendue des pixels valides.

  • UPDATE_BOUNDARY —La limite sera générée ou mise à jour. C'est la valeur par défaut.
  • NO_BOUNDARY —La limite ne sera pas générée ni mise à jour.

Définit et génère des aperçus pour une mosaïque.

  • UPDATE_OVERVIEWS —Des aperçus seront définis et générés.
  • NO_OVERVIEWS —Les aperçus ne seront ni définis ni générés. C'est la valeur par défaut.

Définit le nombre maximal de niveaux de pyramide qui seront utilisés dans la mosaïque. Par exemple, une valeur de 2 utilisera uniquement les deux premiers niveaux de pyramide du raster source. Laisser ce champ vide ou saisir une valeur de -1 créera des pyramides pour tous les niveaux.

Cette valeur peut affecter l'affichage et le nombre d'aperçus qui seront générés.

Définit la taille de cellule de pyramide maximale qui sera utilisée dans la mosaïque.

Définit les dimensions minimales d'une pyramide raster qui sera utilisée dans la mosaïque.

Le système de référence spatiale des données d'entrée.

Ceci doit être spécifié si les données n'ont pas de système de coordonnées, sinon le système de coordonnées de la mosaïque sera utilisé. Cela peut également être utilisé pour remplacer le système de coordonnées des données d'entrée.

Un filtre pour les données ajoutées à la mosaïque. Vous pouvez utiliser des expressions SQL pour créer le filtre de données. Les caractères génériques pour le filtre fonctionnent sur le chemin complet vers les données d'entrée.


Jeudi 13 avril 2017

Analyse de réseau

Figure 2 : Carte des itinéraires
Cela montre que dans de nombreux cas, plusieurs mines se rendent au même terminal ferroviaire. Cela peut avoir un impact énorme sur les routes le long de cette route en raison du chevauchement ainsi que du nombre de voyages effectués à partir de chaque mine. Cela montre également que le Minnesota est touché ainsi que le Wisconsin car, dans certains cas, le dépôt ferroviaire le plus proche se trouve en fait dans le Minnesota. Cela peut créer plusieurs problèmes plus compliqués car la majeure partie de l'activité se déroule dans le Wisconsin, alors que cela finit par coûter également au Minnesota en termes de besoins de réparation de routes.

3 réponses 3

je recommande en général ne pas d'utiliser (uniquement) l'IDE ou la syntaxe du langage pour organiser votre code source. D'une part, vous vous attachez à l'environnement : bien organisé dans l'IDE, non organisé dans le dossier, puis vient le jour où vous voudrez peut-être utiliser un différent environnement.

Pour cette raison, j'utilise généralement les trois façons d'organiser ma source en même temps : je sépare ma source en modules fonctionnels, c'est-à-dire en classes liées. Chaque module dispose de son propre espace de noms, dossier physique et dossier IDE. (Dans mon cas, utiliser CMake et source_group() pour générer des fichiers de projet IDE si nécessaire -- préférant personnellement la ligne de commande, Vim et "make".)

Par conséquent, que je regarde le projet depuis l'IDE, depuis la ligne de commande ou depuis un journal de compilateur, foo/some_class.hpp est foo/some_class.cpp est foo::some_class, minimisant ainsi la confusion.

En fait, ma configuration actuellement préférée subdivise chaque répertoire de module en <project>/<module>/<class>.hpp ou <project>/<module>/src/<class>.hpp selon que la classe est utilisée en dehors de son propre module ou non, <project>/<module>/src/<class> .cpp et <project>/<module>/test/<class>_tu.cpp . L'espace de noms est <project>::<module>::<class> , bien sûr.

L'idée ici est que l'interface "externe" de chaque module ( foo ) est documentée par les en-têtes de ce sous-dossier, avec des détails d'implémentation et des tests "cachés" dans les sous-dossiers respectifs.

Mais en fin de compte, cela dépend beaucoup de vos goûts, de ceux de vos co-développeurs et de la portée de votre projet.


Analyse à couche unique

La reclassification ou le recodage d'un jeu de données est généralement l'une des premières étapes entreprises lors de l'analyse raster. La reclassification est essentiellement le processus à couche unique consistant à attribuer une nouvelle valeur de classe ou de plage à tous les pixels du jeu de données en fonction de leurs valeurs d'origine (Figure 8.1 "Reclassification de raster". Par exemple, une grille d'altitude contient généralement une valeur différente pour presque chaque cellule dans Ces valeurs pourraient être simplifiées en agrégeant chaque valeur de pixel en quelques classes discrètes (c. la simplification permet d'avoir moins de valeurs uniques et des besoins de stockage moins élevés.En outre, ces couches reclassées sont souvent utilisées comme entrées dans les analyses secondaires, telles que celles abordées plus loin dans cette section.

Figure 8.1 Reclassification des rasters

Comme décrit dans le chapitre 7 "Analyse géospatiale I : Opérations vectorielles", la mise en mémoire tampon est le processus de création d'un jeu de données en sortie qui contient une zone (ou des zones) d'une largeur spécifiée autour d'une entité en entrée. Dans le cas des jeux de données raster, ces entités en entrée sont données sous la forme d'une cellule de grille ou d'un groupe de cellules de grille contenant une valeur uniforme (par exemple, mettre en mémoire tampon toutes les cellules dont la valeur = 1). Les tampons sont particulièrement adaptés pour déterminer la zone d'influence autour des caractéristiques d'intérêt. Alors que la mise en mémoire tampon des données vectorielles génère une zone d'influence précise à une distance spécifiée de l'entité cible, les zones tampons raster ont tendance à être des approximations représentant les cellules qui se trouvent dans la plage de distance spécifiée de la cible (Figure 8.2 "Tampon raster autour d'une cellule cible ( s)"). La plupart des programmes de système d'information géographique (SIG) calculent les tampons raster en créant une grille de valeurs de distance du centre de la ou des cellules cibles au centre des cellules voisines, puis en reclassant ces distances de telle sorte qu'un « 1 » représente les cellules qui composent cible d'origine, un « 2 » représente les cellules dans la zone tampon définie par l'utilisateur et un « 0 » représente les cellules en dehors des zones cible et tampon. Ces cellules pourraient également être classées davantage pour représenter plusieurs tampons en anneau en incluant des valeurs de « 3 », « 4 », « 5 », et ainsi de suite, pour représenter des distances concentriques autour de la ou des cellules cibles.

Figure 8.2 Tampon raster autour d'une ou plusieurs cellules cibles


ModeleR : Un référentiel de modèles environnementaux comme base de connaissances pour les experts

Dans cet article, nous présentons le développement de Modeleur, un référentiel de modèles accessible depuis le Web, qui permet à l'utilisateur de concevoir, documenter, gérer et exécuter des modèles environnementaux. La technique et les fonctionnalités proposées peuvent être appliquées à n'importe quel contexte scientifique. Sur la base du développement de son ontologie, un système de métadonnées a été mis en place pour documenter le processus de modélisation. L'ensemble de modèles gérés à partir de ModeleR reflète la base de connaissances des experts du système, permettant à d'autres experts de réutiliser, de répliquer et d'approfondir les modèles existants dans le référentiel. Différents niveaux d'intégration ont été inclus, de la description conceptuelle du modèle au processus nécessaire pour exécuter un modèle à partir d'un serveur distant, agissant comme un moteur d'exécution grâce à l'utilisation de gestionnaires de workflow. Dans cet article, nous présentons les problèmes rencontrés ainsi que les solutions trouvées lors du développement d'un prototype de ModeleR mis en place pour la recherche sur les écosystèmes et un laboratoire de surveillance environnementale.

Points forts

► Nous avons développé un référentiel de modèles environnementaux. ► Nous avons analysé et évalué d'autres approches différentes du problème. ► Nous avons conçu et mis en œuvre un schéma de métadonnées pour les modèles environnementaux. ► Le ModeleR permet différents degrés d'intégration pour chaque modèle. ► ModeleR est une base de connaissances pour les modélisateurs qui souhaitent documenter et exécuter des workflows.


Routage en SIG : Quelles sont mes options ?

Je fais donc des recherches académiques centrées sur les SIG. L'un de mes projets en cours implique le routage du chemin le plus court - plus comme l'installation la plus proche en termes ESRI, ou un-à-plusieurs autrement. Le problème que je rencontre est l'échelle. Ce projet nécessite les éléments suivants :

Routage à l'échelle mondiale, incluant une grille de résille des océans.

Utilise actuellement l'analyste de réseau ESRI.

Utilisation des barrières et restrictions.

Le modèle est exécuté un certain nombre de fois, les points de départ et d'arrivée ne changent pas, contrairement aux barrières et aux restrictions.

Les barrières doivent alourdir le réseau pour ralentir ou accélérer selon les barrières, les restrictions sont des restrictions normales.

Compte tenu de tout cela, ce modèle prend TOUJOURS à fonctionner, il faut une heure pour charger les barrières/restrictions, puis encore plus de temps pour calculer réellement l'itinéraire.

Le réseau que j'utiliserai sera une combinaison de ma grille de résille océanique personnalisée et de données de carte mondiale des rues. Des milliards d'arêtes si je devais deviner.

Cela dit, je recherche des solutions qui accéléreront considérablement mon flux de travail. Quelqu'un a-t-il l'expérience de ce type de routage ? J'ai pris en compte les éléments suivants :

Machine de routage Open Source : je ne sais pas si cela me permettra de modéliser les restrictions et les barrières dont j'ai besoin.

Amazon EC2 Cloud Builder pour ArcGIS : semble prometteur, est-ce que quelqu'un sait si je peux utiliser un analyste de réseau dans l'instance EC2 et lui permettre d'étendre les ressources selon les besoins pour réduire le temps de calcul ?

Routage python pur avec théorie des graphes et autres ? Existe-t-il des packages pour cela ? J'ai une compréhension assez décente de python.

Packages géospatiaux C++ ? Je sais que C++ est meilleur pour le multithreading et autres. Je ne le sais pas mais je suis prêt à essayer si c'est la bonne réponse.

J'ai joué avec PostgreSQL/PostGIS/pgRouting et je l'ai fait fonctionner sur un petit (

8 millions de nœuds), est-ce que quelqu'un sait si cela s'adapterait bien à d'énormes réseaux ?

Comme vous pouvez le voir, je suis vraiment partout, j'ai juste besoin d'une solution de travail bientôt. Selon mes derniers calculs, avec la quantité de données dont je dispose et le nombre total d'itérations du modèle que je dois exécuter, il me faudra un peu plus d'une décennie pour terminer ce projet, que je n'ai pas obtenu.


Jeudi 28 juillet 2016

Exercice 8 : Traitement raster avec booléens et boucle

Les objectifs

L'objectif de cet exercice était de découper des fichiers raster numérisés et de les fusionner à l'aide de booléens et de boucles.

  • Importer des modules.
  • Créez des variables, configurez l'espace de travail et créez des listes vides.
  • Créez un objet de référence spatiale (un système de coordonnées d'index de tuile a été utilisé).
  • Mettre en place une boucle.
  • Place les fichiers des critères spécifiés dans une liste raster.
  • Configurez des boucles de traitement pour chaque raster.
  • Formatez le nom du raster.
  • Projetez tous les rasters.
  • Créez un polygone de l'empreinte topographique du raster.
  • Ajoutez le nom du raster à un nouveau champ.
  • Créez une liste de tuiles pour une fonction de fusion.
  • Fusionner les tuiles.
  • Créez une instruction "IF" pour configurer une boucle "for, in".
  • Découpez les trames.
  • Fusionnez les rasters ensemble.

# importer des modules système
importer le système d'exploitation
Importer un arrêt
heure d'importation
date/heure d'importation
importer arcpy
à partir d'arcpy importer env
de l'importation arcpy.sa *
à partir de l'importation arcpy.ddd *
#-------------------------------------------------------------------------------

#Autoriser le script à écraser les fichiers existants
arcpy.env.workspace = "Q:StudentCourseworkCHupyGEOG.491.801.2167MILLERZMExercise_8Topos"
arcpy.env.overwriteOutput = True
arcpy.env.outputCoordinateSystem = arcpy.SpatialReference ("WGS 1984 UTM Zone 16N")
arcpy.CheckOutExtension('3D')
arcpy.CheckOutExtension('spatial')

#créer des variables
print "Obtention d'une liste de rasters" ,datetime.datetime.now().strftime("%H:%M:%S")

#créer un jeu de classes d'entités dans votre géodatabase à l'aide du système de coordonnées WGS84 UTM Zone 16N
featureDatasetPath = "Q:StudentCourseworkCHupyGEOG.491.801.2167MILLERZMExercise_8Ex8.gdbWisconsinTiles"

#Créer une géodatabase scratch pour les topos découpés
clipGeodatabasePath = "Q:StudentCourseworkCHupyGEOG.491.801.2167MILLERZMExercise_8Ex8.gdb"

mergedFolderLocation = "Q:StudentCourseworkCHupyGEOG.491.801.2167MILLERZMExercise_8Ex8.gdb"
mergedName = "KettleMoraine_Merged"

createIndex = True
clipRasters = Vrai
mosaïqueRasters = True

mergedTiles = os.path.join(featureDatasetPath,mergedName)+ "_TileFootprints"
#-------------------------------------------------------------------------------

#Créer un objet de référence spatiale, en utilisant le système de coordonnées de l'index de tuile
sr=arcpy.Describe(clipTileIndex).spatialReference
#-------------------------------------------------------------------------------

#Si le booléen pour créer l'index est vrai, exécutez le code suivant.
if(createIndex==True) :

#La fonction de marche parcourt un espace de travail et trouve les fichiers avec le type de fichier spécifié
#dans ce cas, il trouve les fichiers TIF. Il contient le chemin du répertoire, le nom du répertoire et les noms de fichiers dans l'objet 'walk'
marche = arcpy.da.Walk(espace de travail, type="TIF")
#-------------------------------------------------------------------------------
#i, j et k sont des variables qui seront utilisées pour connaître la progression de la boucle
je = 0
j = 0
k = 0
#-------------------------------------------------------------------------------

pour dirpath, dirnames, filenames in walk :
pour le nom de fichier dans les noms de fichiers :
#Le script parcourra tous les sous-dossiers et ajoutera tous les tifs valides à la liste 'rasters'
rasters.append(os.path.join(dirpath, filename))
#Pour chaque raster valide, 1 valeur sera ajoutée à i. qui dira finalement combien de fichiers valides il y a
je = je+1
#-------------------------------------------------------------------------------

#Les opérations suivantes seront effectuées sur tous les rasters dans 'rasters'
pour raster en rasters :
#-------------------------------------------------------------------------------

#pour la première itération, j = 0 la valeur 'k' sera # de rasters valides-0.
#pour les itérations suivantes, il décomptera jusqu'à ce qu'il ne reste plus de rasters.
k = i-j
print str(k) + "rasters restants"
#-------------------------------------------------------------------------------

#Mise en forme du nom du topo, dans une première tentative pour remplacer les espaces par des traits de soulignement
outName = os.path.basename(raster).rstrip(os.path.splitext(raster)[1])
imprimerNom
outName = str(outName)
outName2 = outName.replace(" ","_")

#En divisant la chaîne à l'aide de l'index du 3ème caractère, on saute le "WI_" dans le nom de fichier
raccourci=str(outName[3:])
#Ensuite, nous utilisons la fonction 'index' de la chaîne pour identifier l'index du prochain trait de soulignement dans la chaîne (il suit directement la fin du nom de fichier !)
endIndex=shortened.index("_")+3

#En utilisant ces deux nouveaux indices, nous créons une nouvelle chaîne contenant uniquement le nom du fichier
name1 = str(outName[3:endIndex])
#utilisez la fonction de chaîne 'replace' pour supprimer complètement les espaces des noms de fichiers résultants
nom2 = nom1.replace(" ","_")

rasterProj = os.path.join(clipGeodatabasePath,name2) + "_Proj"
rasterTile = os.path.join(featureDatasetPath,name2)+"_Footprint"
#-------------------------------------------------------------------------------

print "Projection " + name2 ,datetime.datetime.now().strftime("%H:%M:%S")
arcpy.ProjectRaster_management(raster,rasterProj,"","BILINEAR")
#-------------------------------------------------------------------------------

#Créer un polygone de l'empreinte du topo, y compris le col
print "Calcul du domaine raster"
arcpy.RasterDomain_3d(rasterProj,rasterTile,"POLYGONE")
#-------------------------------------------------------------------------------

#ajouter un champ pour contenir le nom de chemin du raster projeté dans la table attributaire du polygone
print "Ajout d'un champ"
arcpy.AddField_management(rasterTile,field,"TEXT")

#L'expression suivante sera utilisée pour définir la valeur du nouveau champ sur le nom du raster projeté, à l'aide d'un curseur de mise à jour
expression = str(rasterProj)

print "Champ de calcul" ,datetime.datetime.now().strftime("%H:%M:%S")
avec arcpy.da.UpdateCursor(rasterTile,field) comme curseur :
pour la ligne du curseur :
ligne[0] = expression
La ligne #Update doit être utilisée pour que les modifications prennent effet !
curseur.updateRow(ligne)
du curseur
#-------------------------------------------------------------------------------

#ajout de la vignette à une liste de vignettes pour une fonction de fusion
tileList.append(rasterTile)

if(clipRasters==True) :
#créer un curseur pour parcourir les rasters, tuile par tuile
print "Coupe les colliers des rasters " ,datetime.datetime.now().strftime("%H:%M:%S")
curseurForTopos = arcpy.da.SearchCursor(mergedTiles, champ)
rastersVersMosaic=[]

#obtenir uniquement le nom de fichier de base de la chaîne précédente
inputRasterName = os.path.basename(inputRaster).rstrip(os.path.splitext(inputRaster)[1])

#Dans python, quand on veut mettre une chaîne entre certains guillemets, ils peuvent le spécifier en utilisant '%s' comme espace réservé, puis en utilisant un seul % avant la chaîne qu'ils souhaitent remplacer
#Cela permettra au raster d'entrée d'être enregistré en tant que 'inputRaster', dans la chaîne.
value = "'%s'" % inputRaster

#La ligne suivante permet la création d'une requête SQL en utilisant une substitution de chaîne pour remplacer les deux espaces réservés par le
#champ de nom de chaîne et la valeur 'inputRaster' nouvellement formatée
layerCreationSQLExpression = "%s = %s" % (rasterNameField, valeur)

#Cette ligne utilise l'instruction SQL nouvellement créée pour sélectionner uniquement la vignette qui correspond à la valeur du curseur, ce qui est incroyablement
#important pour les prochaines étapes.
arcpy.MakeFeatureLayer_management(mergedTiles,rasterBoundary,layerCreationSQLExpression)

#Cette ligne sélectionne l'entité de l'index de tuile d'état qui a son centre dans le polygone précédemment sélectionné
arcpy.SelectLayerByLocation_management(clipBoundary,"HAVE_THEIR_CENTER_IN",rasterBoundary,"","NEW_SELECTION")

# Cette logique existe pour identifier si le raster a déjà été généré pour une tuile spécifique, et ignore l'opération si elle a déjà été effectuée
if arcpy.Exists(outputRaster):
print inputRasterName + " a déjà été tronqué"
rastersVersMosaic.append(outputRaster)
autre:
# Le raster sera découpé par la limite identifiée à l'aide de la fonction de sélection de couche par emplacement.
print " Clipping " + inputRasterName ,datetime.datetime.now().strftime("%H:%M:%S")
arcpy.Clip_management(inputRaster,"",outputRaster,clipBoundary,"","ClippingGeometry","NO_MAINTAIN_EXTENT")
print inputRasterName + " Clipped " ,datetime.datetime.now().strftime("%H:%M:%S")
rastersVersMosaic.append(outputRaster)

#Cette fonction del est essentielle, sinon un verrou de schéma peut rester sur votre géodatabase, vous empêchant d'accéder à son contenu jusqu'au redémarrage d'ArcMap.
del curseurPourTopos
#-------------------------------------------------------------------------------

if(mosaicRasters==True):
print "Mosaicing Topos" ,datetime.datetime.now().strftime("%H:%M:%S")
arcpy.MosaicToNewRaster_management(rastersToMosaic,mergedFolderLocation,mergedName,sr,"8_BIT_UNSIGNED","",3)
print "Mosaicing Complete" ,datetime.datetime.now().strftime("%H:%M:%S")

print "Script terminé !" ,datetime.datetime.now().strftime("%H:%M:%S")


Jeudi 28 juillet 2016

Exercice 8 : Traitement raster avec booléens et boucle

Les objectifs

L'objectif de cet exercice était de découper des fichiers raster numérisés et de les fusionner à l'aide de booléens et de boucles.

  • Importer des modules.
  • Créez des variables, configurez l'espace de travail et créez des listes vides.
  • Créez un objet de référence spatiale (un système de coordonnées d'index de tuile a été utilisé).
  • Mettre en place une boucle.
  • Place les fichiers des critères spécifiés dans une liste raster.
  • Configurez des boucles de traitement pour chaque raster.
  • Formatez le nom du raster.
  • Projetez tous les rasters.
  • Créez un polygone de l'empreinte topographique du raster.
  • Ajoutez le nom du raster à un nouveau champ.
  • Créez une liste de tuiles pour une fonction de fusion.
  • Fusionner les tuiles.
  • Créez une instruction "IF" pour configurer une boucle "for, in".
  • Découpez les trames.
  • Fusionnez les rasters ensemble.

# importer des modules système
importer le système d'exploitation
Importer un arrêt
heure d'importation
date/heure d'importation
importer arcpy
à partir d'arcpy importer env
de l'importation arcpy.sa *
à partir de l'importation arcpy.ddd *
#-------------------------------------------------------------------------------

#Autoriser le script à écraser les fichiers existants
arcpy.env.workspace = "Q:StudentCourseworkCHupyGEOG.491.801.2167MILLERZMExercise_8Topos"
arcpy.env.overwriteOutput = True
arcpy.env.outputCoordinateSystem = arcpy.SpatialReference ("WGS 1984 UTM Zone 16N")
arcpy.CheckOutExtension('3D')
arcpy.CheckOutExtension('spatial')

#créer des variables
print "Obtention d'une liste de rasters" ,datetime.datetime.now().strftime("%H:%M:%S")

#créer un jeu de classes d'entités dans votre géodatabase à l'aide du système de coordonnées WGS84 UTM Zone 16N
featureDatasetPath = "Q:StudentCourseworkCHupyGEOG.491.801.2167MILLERZMExercise_8Ex8.gdbWisconsinTiles"

#Créer une géodatabase scratch pour les topos découpés
clipGeodatabasePath = "Q:StudentCourseworkCHupyGEOG.491.801.2167MILLERZMExercise_8Ex8.gdb"

mergedFolderLocation = "Q:StudentCourseworkCHupyGEOG.491.801.2167MILLERZMExercise_8Ex8.gdb"
mergedName = "KettleMoraine_Merged"

createIndex = True
clipRasters = Vrai
mosaïqueRasters = Vrai

mergedTiles = os.path.join(featureDatasetPath,mergedName)+ "_TileFootprints"
#-------------------------------------------------------------------------------

#Créer un objet de référence spatiale, en utilisant le système de coordonnées de l'index de tuile
sr=arcpy.Describe(clipTileIndex).spatialReference
#-------------------------------------------------------------------------------

#Si le booléen pour créer l'index est vrai, exécutez le code suivant.
if(createIndex==True) :

#La fonction walk parcourt un espace de travail et trouve les fichiers avec le type de fichier spécifié
#dans ce cas, il trouve les fichiers TIF. Il contient le chemin du répertoire, le nom du répertoire et les noms de fichiers dans l'objet 'walk'
marche = arcpy.da.Walk(espace de travail, type="TIF")
#-------------------------------------------------------------------------------
#i, j et k sont des variables qui seront utilisées pour connaître la progression de la boucle
je = 0
j = 0
k = 0
#-------------------------------------------------------------------------------

pour dirpath, dirnames, filenames in walk :
pour le nom de fichier dans les noms de fichiers :
#Le script parcourra tous les sous-dossiers et ajoutera tous les tifs valides à la liste 'rasters'
rasters.append(os.path.join(dirpath, filename))
#Pour chaque raster valide, 1 valeur sera ajoutée à i. qui dira finalement combien de fichiers valides il y a
je = je+1
#-------------------------------------------------------------------------------

#Les opérations suivantes seront effectuées sur tous les rasters dans 'rasters'
pour raster en rasters :
#-------------------------------------------------------------------------------

#pour la première itération, j = 0 la valeur 'k' sera # de rasters valides-0.
#pour les itérations suivantes, il décomptera jusqu'à ce qu'il ne reste plus de rasters.
k = i-j
print str(k) + "rasters restants"
#-------------------------------------------------------------------------------

#Mise en forme du nom du topo, dans une première tentative pour remplacer les espaces par des traits de soulignement
outName = os.path.basename(raster).rstrip(os.path.splitext(raster)[1])
imprimer Nom
outName = str(outName)
outName2 = outName.replace(" ","_")

#En divisant la chaîne à l'aide de l'index du 3ème caractère, on saute le "WI_" dans le nom de fichier
raccourci=str(outName[3:])
#Ensuite, nous utilisons la fonction 'index' de la chaîne pour identifier l'index du prochain trait de soulignement dans la chaîne (il suit directement la fin du nom de fichier !)
endIndex=shortened.index("_")+3

#En utilisant ces deux nouveaux indices, nous créons une nouvelle chaîne contenant uniquement le nom du fichier
name1 = str(outName[3:endIndex])
#utilisez la fonction de chaîne 'replace' pour supprimer complètement les espaces des noms de fichiers résultants
nom2 = nom1.replace(" ","_")

rasterProj = os.path.join(clipGeodatabasePath,name2) + "_Proj"
rasterTile = os.path.join(featureDatasetPath,name2)+"_Footprint"
#-------------------------------------------------------------------------------

print "Projection " + name2 ,datetime.datetime.now().strftime("%H:%M:%S")
arcpy.ProjectRaster_management(raster,rasterProj,"","BILINEAR")
#-------------------------------------------------------------------------------

#Créer un polygone de l'empreinte du topo, y compris le col
print "Calcul du domaine raster"
arcpy.RasterDomain_3d(rasterProj,rasterTile,"POLYGONE")
#-------------------------------------------------------------------------------

#ajouter un champ pour contenir le nom de chemin du raster projeté dans la table attributaire du polygone
print "Ajout d'un champ"
arcpy.AddField_management(rasterTile,field,"TEXT")

#L'expression suivante sera utilisée pour définir la valeur du nouveau champ sur le nom du raster projeté, à l'aide d'un curseur de mise à jour
expression = str(rasterProj)

print "Champ de calcul" ,datetime.datetime.now().strftime("%H:%M:%S")
avec arcpy.da.UpdateCursor(rasterTile,field) comme curseur :
pour la ligne du curseur :
ligne[0] = expression
La ligne #Update doit être utilisée pour que les modifications prennent effet !
curseur.updateRow(ligne)
du curseur
#-------------------------------------------------------------------------------

#ajout de la tuile à une liste de tuiles pour une fonction de fusion
tileList.append(rasterTile)

if(clipRasters==True) :
#créer un curseur pour parcourir les rasters, tuile par tuile
print "Découper les colliers des rasters " ,datetime.datetime.now().strftime("%H:%M:%S")
curseurForTopos = arcpy.da.SearchCursor(mergedTiles, champ)
rastersVersMosaic=[]

#obtenir uniquement le nom de fichier de base de la chaîne précédente
inputRasterName = os.path.basename(inputRaster).rstrip(os.path.splitext(inputRaster)[1])

#Dans python, quand on veut mettre une chaîne entre certains guillemets, ils peuvent le spécifier en utilisant '%s' comme espace réservé, puis en utilisant un seul % avant la chaîne qu'ils souhaitent remplacer
#Cela permettra au raster d'entrée d'être enregistré en tant que 'inputRaster', dans la chaîne.
value = "'%s'" % inputRaster

#La ligne suivante permet la création d'une requête SQL en utilisant une substitution de chaîne pour remplacer les deux espaces réservés par le
#champ de nom de chaîne et la valeur 'inputRaster' nouvellement formatée
layerCreationSQLExpression = "%s = %s" % (rasterNameField, valeur)

#Cette ligne utilise l'instruction SQL nouvellement créée pour sélectionner uniquement la vignette qui correspond à la valeur du curseur, ce qui est incroyablement
#important pour les prochaines étapes.
arcpy.MakeFeatureLayer_management(mergedTiles,rasterBoundary,layerCreationSQLExpression)

#Cette ligne sélectionne l'entité de l'index de tuile d'état qui a son centre dans le polygone précédemment sélectionné
arcpy.SelectLayerByLocation_management(clipBoundary,"HAVE_THEIR_CENTER_IN",rasterBoundary,"","NEW_SELECTION")

# Cette logique existe pour identifier si le raster a déjà été généré pour une tuile spécifique, et ignore l'opération si elle a déjà été effectuée
if arcpy.Exists(outputRaster):
print inputRasterName + " a déjà été tronqué"
rastersVersMosaic.append(outputRaster)
autre:
# Le raster sera découpé par la limite identifiée à l'aide de la fonction de sélection de couche par emplacement.
print " Clipping " + inputRasterName ,datetime.datetime.now().strftime("%H:%M:%S")
arcpy.Clip_management(inputRaster,"",outputRaster,clipBoundary,"","ClippingGeometry","NO_MAINTAIN_EXTENT")
print inputRasterName + " Clipped " ,datetime.datetime.now().strftime("%H:%M:%S")
rastersVersMosaic.append(outputRaster)

#Cette fonction del est essentielle, sinon un verrou de schéma peut rester sur votre géodatabase, vous empêchant d'accéder à son contenu jusqu'au redémarrage d'ArcMap.
del curseurPourTopos
#-------------------------------------------------------------------------------

if(mosaicRasters==True):
print "Mosaicing Topos" ,datetime.datetime.now().strftime("%H:%M:%S")
arcpy.MosaicToNewRaster_management(rastersToMosaic,mergedFolderLocation,mergedName,sr,"8_BIT_UNSIGNED","",3)
print "Mosaicing Complete" ,datetime.datetime.now().strftime("%H:%M:%S")

print "Script terminé !" ,datetime.datetime.now().strftime("%H:%M:%S")


Données de traitement par lots sur les serveurs ENVI 

Vous pouvez traiter par lots plusieurs ensembles de données sur différents serveurs ENVI. C'est une bonne option si les ordinateurs ENVI Server disposent de ressources système puissantes et que vous souhaitez répartir le travail entre ces ordinateurs. Pour ce faire, ajoutez un nœud Iterator à un modèle qui traite plusieurs jeux de données d'entrée. Cliquez sur le bouton dans le nœud Itérateur pour afficher la boîte de dialogue Définir les serveurs ENVI . Utilisez cette boîte de dialogue pour sélectionner les serveurs ENVI  existants ou pour en ajouter de nouveaux. Le Valider les URL maintenant est sélectionnée par défaut, ce qui signifie que les URL seront validées lorsque vous cliquerez d'accord dans la boîte de dialogue Définir les serveurs ENVI . Si vous avez déjà validé les URL ailleurs, vous pouvez sélectionner Ne pas valider (plus rapide), qui ignorera l'étape de validation lors de l'exécution du modèle.

Voir la rubrique ENVI Servers pour plus d'informations.

Si le nœud Itérateur est connecté directement à un nœud Agrégateur, ou connecté par plusieurs tâches à un nœud Agrégateur, le modèle ne peut pas être exécuté sur un serveur ENVI . Dans ce cas, vous pouvez écrire un programme dans ENVI API  (à l'aide de la routine ENVIServer) pour envoyer un travail à plusieurs ordinateurs serveurs et collecter les résultats pour un traitement ultérieur.


Voir la vidéo: Clip Multiple Raster Images using Iterate Raster Model Builder in ArcGIS (Octobre 2021).