Python'da bir rasterdeki nokta verilerinin bilinear enterpolasyonu?

Bazı enterpolasyonlar yapmak istediğim bir rasterim var. İşte buradayım:

from osgeo import gdal
from numpy import array

# Read raster
source = gdal.Open('my_raster.tif')
nx, ny = source.RasterXSize, source.RasterYSize
gt = source.GetGeoTransform()
band_array = source.GetRasterBand(1).ReadAsArray()
# Close raster
source = None

# Compute mid-point grid spacings
ax = array([gt[0] + ix*gt[1] + gt[1]/2.0 for ix in range(nx)])
ay = array([gt[3] + iy*gt[5] + gt[5]/2.0 for iy in range(ny)])

Şimdiye kadar SciPy'nin interp2d işlevini denedim :

from scipy import interpolate
bilinterp = interpolate.interp2d(ax, ay, band_array, kind='linear')

ancak 327 Windows sistemimde 317 × 301 tarama ile bir bellek hatası alıyorum:

Traceback (most recent call last):
  File "<interactive input>", line 1, in <module>
  File "C:\Python25\Lib\site-packages\scipy\interpolate\interpolate.py", line 125, in __init__
    self.tck = fitpack.bisplrep(self.x, self.y, self.z, kx=kx, ky=ky, s=0.)
  File "C:\Python25\Lib\site-packages\scipy\interpolate\fitpack.py", line 873, in bisplrep
tx,ty,nxest,nyest,wrk,lwrk1,lwrk2)
MemoryError

Kabul edeceğim, bounds_errorveya SciPy işlevine olan güvenim sınırlı, çünkü veya fill_valueparametreleri belgelendiği gibi çalışmıyor. Rasterim 317 × 301 olduğundan ve bilinear algoritmanın zor olmaması gerektiğinden neden bir bellek hatasına sahip olmam gerektiğini anlamıyorum .

Muhtemelen NumPy ile uyarlanmış, tercihen Python'da iyi bir bilinear enterpolasyon algoritmasıyla karşılaşan var mı? Herhangi bir ipucu veya tavsiye var mı?

(Not: en yakın komşu enterpolasyon algoritması kolay kek:

from numpy import argmin, NAN

def nearest_neighbor(px, py, no_data=NAN):
    '''Nearest Neighbor point at (px, py) on band_array
    example: nearest_neighbor(2790501.920, 6338905.159)'''
    ix = int(round((px - (gt[0] + gt[1]/2.0))/gt[1]))
    iy = int(round((py - (gt[3] + gt[5]/2.0))/gt[5]))
    if (ix < 0) or (iy < 0) or (ix > nx - 1) or (iy > ny - 1):
        return no_data
    else:
        return band_array[iy, ix]

... ama ben bilinear enterpolasyon yöntemlerini çok tercih ediyorum)

Çalıştığımız aşağıdaki algoritmayı elde etmek için aşağıdaki formülü ( Wikipedia'dan ) Python-speak'e çevirdim.

from numpy import floor, NAN

def bilinear(px, py, no_data=NAN):
    '''Bilinear interpolated point at (px, py) on band_array
    example: bilinear(2790501.920, 6338905.159)'''
    ny, nx = band_array.shape
    # Half raster cell widths
    hx = gt[1]/2.0
    hy = gt[5]/2.0
    # Calculate raster lower bound indices from point
    fx = (px - (gt[0] + hx))/gt[1]
    fy = (py - (gt[3] + hy))/gt[5]
    ix1 = int(floor(fx))
    iy1 = int(floor(fy))
    # Special case where point is on upper bounds
    if fx == float(nx - 1):
        ix1 -= 1
    if fy == float(ny - 1):
        iy1 -= 1
    # Upper bound indices on raster
    ix2 = ix1 + 1
    iy2 = iy1 + 1
    # Test array bounds to ensure point is within raster midpoints
    if (ix1 < 0) or (iy1 < 0) or (ix2 > nx - 1) or (iy2 > ny - 1):
        return no_data
    # Calculate differences from point to bounding raster midpoints
    dx1 = px - (gt[0] + ix1*gt[1] + hx)
    dy1 = py - (gt[3] + iy1*gt[5] + hy)
    dx2 = (gt[0] + ix2*gt[1] + hx) - px
    dy2 = (gt[3] + iy2*gt[5] + hy) - py
    # Use the differences to weigh the four raster values
    div = gt[1]*gt[5]
    return (band_array[iy1,ix1]*dx2*dy2/div +
            band_array[iy1,ix2]*dx1*dy2/div +
            band_array[iy2,ix1]*dx2*dy1/div +
            band_array[iy2,ix2]*dx1*dy1/div)

NumPy'nin dtype('float64')veri türüne göre sınıflandırıldığından, sonucun kaynak verilerden daha yüksek bir hassasiyetle döndürüleceğini unutmayın . .astype(band_array.dtype)Çıktı veri türünü girdi dizisiyle aynı yapmak için dönüş değerini ile kullanabilirsiniz.

Yerel olarak benzer sonuçlara denedim, ancak 64 bit bir platformdayım, bu yüzden bellek sınırına ulaşmadı. Belki de bu örnekte olduğu gibi dizinin küçük parçalarını bir seferde enterpolasyonlamayı deneyin .

Bunu sadece GDAL ile de yapabilirsiniz, komut satırından:

gdalwarp -ts $XSIZE*2 0 -r bilinear input.tif interp.tif

Python'da eşdeğer işlemi yapmak için ReprojectImage () kullanın :

mem_drv = gdal.GetDriverByName('MEM')
dest = mem_drv.Create('', nx, ny, 1)

resample_by = 2
dt = (gt[0], gt[1] * resample_by, gt[2], gt[3], gt[4], gt[5] * resample_by)
dest.setGeoTransform(dt)

resampling_method = gdal.GRA_Bilinear    
res = gdal.ReprojectImage(source, dest, None, None, resampling_method)

# then, write the result to a file of your choice...    

Geçmişte kesin bir sorun yaşadım ve asla interpolate.interp2d kullanarak çözmedim. Scipy.ndimage.map_coordinates kullanarak başarılı oldum . Takip etmeyi dene:

scipy.ndimage.map_coordinates (band_array, [ax, ay]], sipariş = 1)

Bu bilinear ile aynı çıktıyı veriyor gibi görünüyor.

scipy.interpolate.interp2d () daha modern scipy ile iyi çalışır. Eski sürümlerin düzensiz ızgaralar aldığını ve normal ızgaralardan faydalanmadığını düşünüyorum. Scipy ile aynı hatayı alıyorum. sürüm = 0.11.0, ancak ürkütücü. sürüm = 0.14.0, bazı 1600x1600 model çıktılarında mutlu bir şekilde çalışır.

Sorunuzdaki ipuçları için teşekkür ederiz.

#!/usr/bin/env python

from osgeo import gdal
from numpy import array
import argparse

parser = argparse.ArgumentParser()
parser.add_argument("filename",help='raster file from which to interpolate a (1/3,1/3) point from from')
args = parser.parse_args()

# Read raster
source = gdal.Open(args.filename)
nx, ny = source.RasterXSize, source.RasterYSize
gt = source.GetGeoTransform()
band_array = source.GetRasterBand(1).ReadAsArray()
# Close raster
source = None

# Compute mid-point grid spacings
ax = array([gt[0] + ix*gt[1] + gt[1]/2.0 for ix in range(nx)])
ay = array([gt[3] + iy*gt[5] + gt[5]/2.0 for iy in range(ny)])

from scipy import interpolate
bilinterp = interpolate.interp2d(ax, ay, band_array, kind='linear')

x1 = gt[0] + gt[1]*nx/3
y1 = gt[3] + gt[5]*ny/3.

print(nx, ny, x1,y1,bilinterp(x1,y1))

####################################

$ time ./interp2dTesting.py test.tif 
(1600, 1600, -76.322, 30.70889, array([-8609.27777778]))

real    0m4.086s
user    0m0.590s
sys 0m0.252s