Viele Raster in R effizient lesen und neu klassifizieren?

Ich wurde beauftragt, eine Eignungsanalyse der Wellenbedingungen im Golf von Mexiko zu erstellen. Ich habe ungefähr zweitausend Rasterdateien mit jeweils ca. 8 MB (2438 Spalten, 1749 Zeilen, 1 km Zellengröße). Der Parameter in den Rasterdateien ist die Wellenperiode, und ich möchte alle Raster so umklassifizieren, dass if 4<= wave period <=9 then make cell = 1, else cell = 0. Dann alle Raster zu einem endgültigen Raster zusammenfassen und durch die Gesamtzahl der Raster dividieren, um a zu erhalten Gesamtprozentsatz geeigneter Beobachtungen und Exportergebnisse in ein ESRI-kompatibles Format ... möglicherweise etwas, das Floats bei Bedarf unterstützen kann. Ich habe weder mit Python noch mit R viel gearbeitet, aber nach der Online-Suche scheint es sinnvoll, diesen Prozess in einer dieser Sprachen durchzuführen. Ich habe mir bisher einen Code in R ausgedacht, bin aber verwirrt darüber, wie das funktioniert.

library(rgdal)
raster_data <- list.files(path=getwd())    #promt user for dir containing raster files
num_files <- length(raster_data)
for (i in raster_data) {                   #read in rasters
   my_data <- readGDAL(raster_data[i])

An diesem Punkt bin ich verwirrt, ob ich auch die Daten innerhalb dieser Schleife neu klassifizieren und summieren soll oder nicht. Meine Vermutung wäre ja, da ich sonst denke, dass mir möglicherweise der Speicher auf meinem Computer ausgehen würde, aber ich bin mir einfach nicht sicher. Ich bin mir auch nicht sicher, wie ich die Daten neu klassifizieren soll.

Bei Online-Recherchen denke ich, ich würde verwenden reclass(my_data, c(-Inf,3,0, 4,9,1, 10,Inf,0)), aber sieht das richtig aus?

Und zum Summieren würde ich das verwenden sum(stack(my_data))und irgendwie ausgeben. Auch ... wenn dies effizienter ausgeführt oder in Python geschrieben werden könnte, wäre ich auch dafür offen. Ich bin wirklich ein Anfänger, wenn es um Programmierung geht.

Dies ist eine kurze Möglichkeit, dies in R zu tun --- hier ohne Zwischendateien:

library(raster)
raster_data <- list.files(path=getwd())    #promt user for dir containing raster files
s <- stack(raster_data)
f <- function(x) { rowSums(x >= 4 & x <= 9) }
x <- calc(s, f, progress='text', filename='output.tif')

Wie ich in den Kommentaren bemerkt habe, sollten Sie R im Allgemeinen aufgrund von Leistungsproblemen in bestimmten Aspekten für nicht statistische Zwecke vermeiden (das Arbeiten mit Zyklen ist ein Beispiel). Hier ist ein Codebeispiel für Sie in Pyhton (dank dieses Artikels ) zur Neuklassifizierung einer einzelnen Datei mit einem einzelnen Band. Sie können es problemlos für die Stapelverarbeitung ändern, wenn Sie wissen, wie Sie alle Dateien aus dem Verzeichnis abrufen . Beachten Sie, dass Raster als Arrays dargestellt werden. Sie können daher Array-Methoden verwenden, um die Leistung gegebenenfalls zu verbessern. Informationen zum Arbeiten mit Arrays in Python finden Sie in der Numpy-Dokumentation .

UPD: Der Code, den ich ursprünglich gepostet habe, war eine abgeschnittene Version eines benutzerdefinierten Filters, der pro Pixelverarbeitung benötigt wurde. Bei dieser Frage erhöht die Verwendung von Numpy jedoch die Leistung (siehe Code).

from osgeo import gdal
import sys
import numpy

gdalData = gdal.Open("path_to_file")
if gdalData is None:
  sys.exit("ERROR: can't open raster")

#print "Driver short name", gdalData.GetDriver().ShortName
#print "Driver long name", gdalData.GetDriver().LongName
#print "Raster size", gdalData.RasterXSize, "x", gdalData.RasterYSize
#print "Number of bands", gdalData.RasterCount
#print "Projection", gdalData.GetProjection()
#print "Geo transform", gdalData.GetGeoTransform()


raster = gdalData.ReadAsArray()
xsize = gdalData.RasterXSize
ysize = gdalData.RasterYSize

#print xsize, 'x', ysize

## per pixel processing
#for col in range(xsize):
#  for row in range(ysize):
#    # if pixel value is 16 - change it to 7
#    if raster[row, col] == 16:
#      raster[row, col] = 7

#reclassify raster values equal 16 to 7 using Numpy
temp = numpy.equal(raster, 16)
numpy.putmask(raster, temp, 7)

# write results to file (but at first check if we are able to write this format)
format = "GTiff"
driver = gdal.GetDriverByName(format)
metadata = driver.GetMetadata()
if metadata.has_key(gdal.DCAP_CREATE) and metadata[gdal.DCAP_CREATE] == "YES":
  pass
else:
  print "Driver %s does not support Create() method." % format
  sys.exit(1)
if metadata.has_key(gdal.DCAP_CREATECOPY) and metadata[gdal.DCAP_CREATECOPY] == "YES":
  pass
else:
  print "Driver %s does not support CreateCopy() method." % format
  sys.exit(1)

# we already have the raster with exact parameters that we need
# so we use CreateCopy() method instead of Create() to save our time
outData = driver.CreateCopy("path_to_new_file", gdalData, 0)
outData.GetRasterBand(1).WriteArray(raster)

1. Verwenden Sie nicht readGDAL. Es liest in ein Spatial * -Objekt ein, was möglicherweise keine gute Idee ist.

2. Verwenden Sie das rasterPaket. Es kann GDAL-Dinge in Raster-Objekte einlesen. Das ist eine gute Sache. r = raster("/path/to/rasterfile.tif")werde es in lesen r.

3. Ihre Klassifizierung ist dann t = r > 4 & r <= 9

4. Die große Frage ist, ob diese in neue Rasterdateien ausgegeben und dann der Zusammenfassungsschritt in einer anderen Schleife ausgeführt werden sollen. Wenn Sie den Speicher haben, würde ich sie in neue Dateien schreiben, nur weil Sie erneut starten müssen, wenn Ihre Schleife fehlschlägt (weil eine dieser 2000 Dateien Junk ist). Verwenden writeRasterSie diese Option, um Raster mit Schwellenwerten zu erstellen, wenn Sie sich dazu entschließen.

5. Ihre Schleife ist dann nur so etwas wie

diese.

count = raster(0,size of your raster)
for(i in 1:number of rasters){
  r = raster(path to binary raster file 'i')
  count = count + r
}
return(count)

Die Speicherverwaltung von R könnte Sie hier treffen - wenn Sie dies tun, erstellt count=count+rR möglicherweise eine neue Kopie von count. Das sind also möglicherweise 2000 Kopien davon - aber die Speicherbereinigung wird aktiviert und aufgeräumt, und hier war die Schleife von R früher sehr schlecht.

In Bezug auf das Timing dauert auf meinem 4-jährigen PC der Schwellenwert op bei einem Raster dieser Größe von Zufallszahlen zwischen null und zwanzig etwa 1,5 Sekunden. Times 2000 = Sie rechnen. Erstellen Sie wie immer einen kleinen Testsatz für die Entwicklung des Codes, starten Sie ihn dann mit Ihren realen Daten und trinken Sie einen Kaffee.